/tests/common/unittest_common.cc

https://github.com/nnsuite/nnstreamer · C++ · 1062 lines · 690 code · 180 blank · 192 comment · 26 complexity · 37f79fd395f13627bdf2b3ed2c7cca16 MD5 · raw file

  1. /**
  2. * @file unittest_common.cc
  3. * @date 31 May 2018
  4. * @author MyungJoo Ham <myungjoo.ham@samsung.com>
  5. * @brief Unit test module for NNStreamer common library
  6. * @see https://github.com/nnstreamer/nnstreamer
  7. * @bug No known bugs.
  8. *
  9. * @brief Unit test module for NNStreamer common library
  10. * @bug No known bugs except for NYI items
  11. *
  12. * Copyright 2018 Samsung Electronics
  13. *
  14. */
  15. #include <gtest/gtest.h>
  16. #include <unistd.h>
  17. #include <tensor_common.h>
  18. #include <glib.h>
  19. #include <glib/gstdio.h>
  20. #include <nnstreamer_conf.h>
  21. #include <nnstreamer_plugin_api.h>
  22. /**
  23. * @brief Test for int32 type string.
  24. */
  25. TEST (common_get_tensor_type, failure_n)
  26. {
  27. EXPECT_EQ (gst_tensor_get_type (""), _NNS_END);
  28. EXPECT_EQ (gst_tensor_get_type (NULL), _NNS_END);
  29. }
  30. /**
  31. * @brief Test for int32 type string.
  32. */
  33. TEST (common_get_tensor_type, int32)
  34. {
  35. EXPECT_EQ (gst_tensor_get_type ("int32"), _NNS_INT32);
  36. EXPECT_EQ (gst_tensor_get_type ("INT32"), _NNS_INT32);
  37. EXPECT_EQ (gst_tensor_get_type ("iNt32"), _NNS_INT32);
  38. EXPECT_EQ (gst_tensor_get_type ("InT32"), _NNS_INT32);
  39. }
  40. /**
  41. * @brief Test for int32 type string.
  42. */
  43. TEST (common_get_tensor_type, int32_n)
  44. {
  45. EXPECT_EQ (gst_tensor_get_type ("InT322"), _NNS_END);
  46. EXPECT_EQ (gst_tensor_get_type ("int3"), _NNS_END);
  47. }
  48. /**
  49. * @brief Test for int16 type string.
  50. */
  51. TEST (common_get_tensor_type, int16)
  52. {
  53. EXPECT_EQ (gst_tensor_get_type ("int16"), _NNS_INT16);
  54. EXPECT_EQ (gst_tensor_get_type ("INT16"), _NNS_INT16);
  55. EXPECT_EQ (gst_tensor_get_type ("iNt16"), _NNS_INT16);
  56. EXPECT_EQ (gst_tensor_get_type ("InT16"), _NNS_INT16);
  57. }
  58. /**
  59. * @brief Test for int16 type string.
  60. */
  61. TEST (common_get_tensor_type, int16_n)
  62. {
  63. EXPECT_EQ (gst_tensor_get_type ("InT162"), _NNS_END);
  64. EXPECT_EQ (gst_tensor_get_type ("int1"), _NNS_END);
  65. }
  66. /**
  67. * @brief Test for int8 type string.
  68. */
  69. TEST (common_get_tensor_type, int8)
  70. {
  71. EXPECT_EQ (gst_tensor_get_type ("int8"), _NNS_INT8);
  72. EXPECT_EQ (gst_tensor_get_type ("INT8"), _NNS_INT8);
  73. EXPECT_EQ (gst_tensor_get_type ("iNt8"), _NNS_INT8);
  74. EXPECT_EQ (gst_tensor_get_type ("InT8"), _NNS_INT8);
  75. }
  76. /**
  77. * @brief Test for int8 type string.
  78. */
  79. TEST (common_get_tensor_type, int8_n)
  80. {
  81. EXPECT_EQ (gst_tensor_get_type ("InT82"), _NNS_END);
  82. EXPECT_EQ (gst_tensor_get_type ("int3"), _NNS_END);
  83. }
  84. /**
  85. * @brief Test for uint32 type string.
  86. */
  87. TEST (common_get_tensor_type, uint32)
  88. {
  89. EXPECT_EQ (gst_tensor_get_type ("uint32"), _NNS_UINT32);
  90. EXPECT_EQ (gst_tensor_get_type ("UINT32"), _NNS_UINT32);
  91. EXPECT_EQ (gst_tensor_get_type ("uiNt32"), _NNS_UINT32);
  92. EXPECT_EQ (gst_tensor_get_type ("UInT32"), _NNS_UINT32);
  93. }
  94. /**
  95. * @brief Test for uint32 type string.
  96. */
  97. TEST (common_get_tensor_type, uint32_n)
  98. {
  99. EXPECT_EQ (gst_tensor_get_type ("UInT322"), _NNS_END);
  100. EXPECT_EQ (gst_tensor_get_type ("uint3"), _NNS_END);
  101. }
  102. /**
  103. * @brief Test for uint16 type string.
  104. */
  105. TEST (common_get_tensor_type, uint16)
  106. {
  107. EXPECT_EQ (gst_tensor_get_type ("uint16"), _NNS_UINT16);
  108. EXPECT_EQ (gst_tensor_get_type ("UINT16"), _NNS_UINT16);
  109. EXPECT_EQ (gst_tensor_get_type ("uiNt16"), _NNS_UINT16);
  110. EXPECT_EQ (gst_tensor_get_type ("UInT16"), _NNS_UINT16);
  111. }
  112. /**
  113. * @brief Test for uint16 type string.
  114. */
  115. TEST (common_get_tensor_type, uint16_n)
  116. {
  117. EXPECT_EQ (gst_tensor_get_type ("UInT162"), _NNS_END);
  118. EXPECT_EQ (gst_tensor_get_type ("uint1"), _NNS_END);
  119. }
  120. /**
  121. * @brief Test for uint8 type string.
  122. */
  123. TEST (common_get_tensor_type, uint8)
  124. {
  125. EXPECT_EQ (gst_tensor_get_type ("uint8"), _NNS_UINT8);
  126. EXPECT_EQ (gst_tensor_get_type ("UINT8"), _NNS_UINT8);
  127. EXPECT_EQ (gst_tensor_get_type ("uiNt8"), _NNS_UINT8);
  128. EXPECT_EQ (gst_tensor_get_type ("UInT8"), _NNS_UINT8);
  129. }
  130. /**
  131. * @brief Test for uint8 type string.
  132. */
  133. TEST (common_get_tensor_type, uint8_n)
  134. {
  135. EXPECT_EQ (gst_tensor_get_type ("UInT82"), _NNS_END);
  136. EXPECT_EQ (gst_tensor_get_type ("uint3"), _NNS_END);
  137. }
  138. /**
  139. * @brief Test for float32 type string.
  140. */
  141. TEST (common_get_tensor_type, float32)
  142. {
  143. EXPECT_EQ (gst_tensor_get_type ("float32"), _NNS_FLOAT32);
  144. EXPECT_EQ (gst_tensor_get_type ("FLOAT32"), _NNS_FLOAT32);
  145. EXPECT_EQ (gst_tensor_get_type ("float32"), _NNS_FLOAT32);
  146. EXPECT_EQ (gst_tensor_get_type ("FloaT32"), _NNS_FLOAT32);
  147. }
  148. /**
  149. * @brief Test for float32 type string.
  150. */
  151. TEST (common_get_tensor_type, float32_n)
  152. {
  153. EXPECT_EQ (gst_tensor_get_type ("FloaT322"), _NNS_END);
  154. EXPECT_EQ (gst_tensor_get_type ("float3"), _NNS_END);
  155. }
  156. /**
  157. * @brief Test for float64 type string.
  158. */
  159. TEST (common_get_tensor_type, float64)
  160. {
  161. EXPECT_EQ (gst_tensor_get_type ("float64"), _NNS_FLOAT64);
  162. EXPECT_EQ (gst_tensor_get_type ("FLOAT64"), _NNS_FLOAT64);
  163. EXPECT_EQ (gst_tensor_get_type ("float64"), _NNS_FLOAT64);
  164. EXPECT_EQ (gst_tensor_get_type ("FloaT64"), _NNS_FLOAT64);
  165. }
  166. /**
  167. * @brief Test for float64 type string.
  168. */
  169. TEST (common_get_tensor_type, float64_n)
  170. {
  171. EXPECT_EQ (gst_tensor_get_type ("FloaT642"), _NNS_END);
  172. EXPECT_EQ (gst_tensor_get_type ("float6"), _NNS_END);
  173. }
  174. /**
  175. * @brief Test for int64 type string.
  176. */
  177. TEST (common_get_tensor_type, int64)
  178. {
  179. EXPECT_EQ (gst_tensor_get_type ("int64"), _NNS_INT64);
  180. EXPECT_EQ (gst_tensor_get_type ("INT64"), _NNS_INT64);
  181. EXPECT_EQ (gst_tensor_get_type ("iNt64"), _NNS_INT64);
  182. EXPECT_EQ (gst_tensor_get_type ("InT64"), _NNS_INT64);
  183. }
  184. /**
  185. * @brief Test for int64 type string.
  186. */
  187. TEST (common_get_tensor_type, int64_n)
  188. {
  189. EXPECT_EQ (gst_tensor_get_type ("InT642"), _NNS_END);
  190. EXPECT_EQ (gst_tensor_get_type ("int6"), _NNS_END);
  191. }
  192. /**
  193. * @brief Test for uint64 type string.
  194. */
  195. TEST (common_get_tensor_type, uint64)
  196. {
  197. EXPECT_EQ (gst_tensor_get_type ("uint64"), _NNS_UINT64);
  198. EXPECT_EQ (gst_tensor_get_type ("UINT64"), _NNS_UINT64);
  199. EXPECT_EQ (gst_tensor_get_type ("uiNt64"), _NNS_UINT64);
  200. EXPECT_EQ (gst_tensor_get_type ("UInT64"), _NNS_UINT64);
  201. }
  202. /**
  203. * @brief Test for uint64 type string.
  204. */
  205. TEST (common_get_tensor_type, uint64_n)
  206. {
  207. EXPECT_EQ (gst_tensor_get_type ("UInT642"), _NNS_END);
  208. EXPECT_EQ (gst_tensor_get_type ("uint6"), _NNS_END);
  209. }
  210. /**
  211. * @brief Test to find index of the key.
  212. */
  213. TEST (common_find_key_strv, key_index)
  214. {
  215. const gchar *teststrv[] = {
  216. "abcde",
  217. "ABCDEF",
  218. "1234",
  219. "abcabc",
  220. "tester",
  221. NULL
  222. };
  223. EXPECT_EQ (find_key_strv (teststrv, "abcde"), 0);
  224. EXPECT_EQ (find_key_strv (teststrv, "ABCDE"), 0);
  225. EXPECT_EQ (find_key_strv (teststrv, "ABCDEF"), 1);
  226. EXPECT_EQ (find_key_strv (teststrv, "1234"), 2);
  227. EXPECT_EQ (find_key_strv (teststrv, "tester"), 4);
  228. EXPECT_EQ (find_key_strv (teststrv, "abcabcd"), -1);
  229. }
  230. /**
  231. * @brief Test for tensor dimension.
  232. */
  233. TEST (common_get_tensor_dimension, case1)
  234. {
  235. tensor_dim dim;
  236. gchar *dim_str;
  237. guint rank;
  238. rank = gst_tensor_parse_dimension ("345:123:433:177", dim);
  239. EXPECT_EQ (rank, 4U);
  240. EXPECT_EQ (dim[0], 345U);
  241. EXPECT_EQ (dim[1], 123U);
  242. EXPECT_EQ (dim[2], 433U);
  243. EXPECT_EQ (dim[3], 177U);
  244. dim_str = gst_tensor_get_dimension_string (dim);
  245. EXPECT_STREQ (dim_str, "345:123:433:177");
  246. g_free (dim_str);
  247. }
  248. /**
  249. * @brief Test for tensor dimension.
  250. */
  251. TEST (common_get_tensor_dimension, case2)
  252. {
  253. tensor_dim dim;
  254. gchar *dim_str;
  255. guint rank;
  256. rank = gst_tensor_parse_dimension ("345:123:433", dim);
  257. EXPECT_EQ (rank, 3U);
  258. EXPECT_EQ (dim[0], 345U);
  259. EXPECT_EQ (dim[1], 123U);
  260. EXPECT_EQ (dim[2], 433U);
  261. EXPECT_EQ (dim[3], 1U);
  262. dim_str = gst_tensor_get_dimension_string (dim);
  263. EXPECT_STREQ (dim_str, "345:123:433:1");
  264. g_free (dim_str);
  265. }
  266. /**
  267. * @brief Test for tensor dimension.
  268. */
  269. TEST (common_get_tensor_dimension, case3)
  270. {
  271. tensor_dim dim;
  272. gchar *dim_str;
  273. guint rank;
  274. rank = gst_tensor_parse_dimension ("345:123", dim);
  275. EXPECT_EQ (rank, 2U);
  276. EXPECT_EQ (dim[0], 345U);
  277. EXPECT_EQ (dim[1], 123U);
  278. EXPECT_EQ (dim[2], 1U);
  279. EXPECT_EQ (dim[3], 1U);
  280. dim_str = gst_tensor_get_dimension_string (dim);
  281. EXPECT_STREQ (dim_str, "345:123:1:1");
  282. g_free (dim_str);
  283. }
  284. /**
  285. * @brief Test for tensor dimension.
  286. */
  287. TEST (common_get_tensor_dimension, case4)
  288. {
  289. tensor_dim dim;
  290. gchar *dim_str;
  291. guint rank;
  292. rank = gst_tensor_parse_dimension ("345", dim);
  293. EXPECT_EQ (rank, 1U);
  294. EXPECT_EQ (dim[0], 345U);
  295. EXPECT_EQ (dim[1], 1U);
  296. EXPECT_EQ (dim[2], 1U);
  297. EXPECT_EQ (dim[3], 1U);
  298. dim_str = gst_tensor_get_dimension_string (dim);
  299. EXPECT_STREQ (dim_str, "345:1:1:1");
  300. g_free (dim_str);
  301. }
  302. /**
  303. * @brief Test to copy tensor info.
  304. */
  305. TEST (common_tensor_info, copy_tensor)
  306. {
  307. GstTensorInfo src, dest;
  308. gchar *test_name = g_strdup ("test-tensor");
  309. gst_tensor_info_init (&src);
  310. gst_tensor_info_init (&dest);
  311. src = { test_name, _NNS_FLOAT32, { 1, 2, 3, 4 } };
  312. gst_tensor_info_copy (&dest, &src);
  313. EXPECT_TRUE (dest.name != src.name);
  314. EXPECT_STREQ (dest.name, test_name);
  315. EXPECT_EQ (dest.type, src.type);
  316. EXPECT_EQ (dest.dimension[0], src.dimension[0]);
  317. EXPECT_EQ (dest.dimension[1], src.dimension[1]);
  318. EXPECT_EQ (dest.dimension[2], src.dimension[2]);
  319. EXPECT_EQ (dest.dimension[3], src.dimension[3]);
  320. src = { NULL, _NNS_INT32, { 5, 6, 7, 8 } };
  321. gst_tensor_info_copy (&dest, &src);
  322. EXPECT_TRUE (dest.name == NULL);
  323. EXPECT_EQ (dest.type, src.type);
  324. EXPECT_EQ (dest.dimension[0], src.dimension[0]);
  325. EXPECT_EQ (dest.dimension[1], src.dimension[1]);
  326. EXPECT_EQ (dest.dimension[2], src.dimension[2]);
  327. EXPECT_EQ (dest.dimension[3], src.dimension[3]);
  328. g_free (test_name);
  329. }
  330. /**
  331. * @brief Test to copy tensor info.
  332. */
  333. TEST (common_tensor_info, copy_tensors)
  334. {
  335. GstTensorsInfo src, dest;
  336. gchar *test_name = g_strdup ("test-tensors");
  337. guint i;
  338. gst_tensors_info_init (&src);
  339. gst_tensors_info_init (&dest);
  340. src.num_tensors = 2;
  341. src.info[0] = { test_name, _NNS_INT32, { 1, 2, 3, 4 } };
  342. src.info[1] = { test_name, _NNS_FLOAT32, { 5, 6, 7, 8 } };
  343. gst_tensors_info_copy (&dest, &src);
  344. EXPECT_EQ (dest.num_tensors, src.num_tensors);
  345. for (i = 0; i < src.num_tensors; i++) {
  346. EXPECT_TRUE (dest.info[i].name != src.info[i].name);
  347. EXPECT_STREQ (dest.info[i].name, test_name);
  348. EXPECT_EQ (dest.info[i].type, src.info[i].type);
  349. EXPECT_EQ (dest.info[i].dimension[0], src.info[i].dimension[0]);
  350. EXPECT_EQ (dest.info[i].dimension[1], src.info[i].dimension[1]);
  351. EXPECT_EQ (dest.info[i].dimension[2], src.info[i].dimension[2]);
  352. EXPECT_EQ (dest.info[i].dimension[3], src.info[i].dimension[3]);
  353. }
  354. g_free (test_name);
  355. }
  356. /**
  357. * @brief Internal function to update tensors info.
  358. */
  359. static void
  360. fill_tensors_info_for_test (GstTensorsInfo * info1, GstTensorsInfo * info2)
  361. {
  362. g_assert (info1 != NULL && info2 != NULL);
  363. gst_tensors_info_init (info1);
  364. gst_tensors_info_init (info2);
  365. info1->num_tensors = info2->num_tensors = 2;
  366. info1->info[0].type = info2->info[0].type = _NNS_INT64;
  367. info1->info[1].type = info2->info[1].type = _NNS_FLOAT64;
  368. info1->info[0].dimension[0] = info2->info[0].dimension[0] = 2;
  369. info1->info[0].dimension[1] = info2->info[0].dimension[1] = 3;
  370. info1->info[0].dimension[2] = info2->info[0].dimension[2] = 1;
  371. info1->info[0].dimension[3] = info2->info[0].dimension[3] = 1;
  372. info1->info[1].dimension[0] = info2->info[1].dimension[0] = 5;
  373. info1->info[1].dimension[1] = info2->info[1].dimension[1] = 5;
  374. info1->info[1].dimension[2] = info2->info[1].dimension[2] = 1;
  375. info1->info[1].dimension[3] = info2->info[1].dimension[3] = 1;
  376. }
  377. /**
  378. * @brief Internal function to update tensors info.
  379. */
  380. static void
  381. fill_tensors_config_for_test (GstTensorsConfig * conf1, GstTensorsConfig * conf2)
  382. {
  383. g_assert (conf1 != NULL && conf2 != NULL);
  384. gst_tensors_config_init (conf1);
  385. gst_tensors_config_init (conf2);
  386. conf1->rate_n = conf2->rate_n = 1;
  387. conf1->rate_d = conf2->rate_d = 2;
  388. fill_tensors_info_for_test (&conf1->info, &conf2->info);
  389. }
  390. /**
  391. * @brief Test for data size.
  392. */
  393. TEST (common_tensor_info, size_01_p)
  394. {
  395. GstTensorsInfo info1, info2;
  396. gsize size1, size2;
  397. guint i;
  398. fill_tensors_info_for_test (&info1, &info2);
  399. size1 = gst_tensor_info_get_size (&info1.info[0]);
  400. size2 = gst_tensors_info_get_size (&info1, 0);
  401. EXPECT_TRUE (size1 == size2);
  402. size1 = 0;
  403. for (i = 0; i < info2.num_tensors; i++) {
  404. size1 += gst_tensor_info_get_size (&info2.info[i]);
  405. }
  406. size2 = gst_tensors_info_get_size (&info2, -1);
  407. EXPECT_TRUE (size1 == size2);
  408. }
  409. /**
  410. * @brief Test for data size.
  411. */
  412. TEST (common_tensor_info, size_02_n)
  413. {
  414. GstTensorsInfo info1, info2;
  415. gsize size1;
  416. gint index;
  417. fill_tensors_info_for_test (&info1, &info2);
  418. /* get size with null param */
  419. index = (gint) info1.num_tensors - 1;
  420. size1 = gst_tensors_info_get_size (NULL, index);
  421. EXPECT_TRUE (size1 == 0);
  422. }
  423. /**
  424. * @brief Test for data size.
  425. */
  426. TEST (common_tensor_info, size_03_n)
  427. {
  428. GstTensorsInfo info1, info2;
  429. gsize size1;
  430. gint index;
  431. fill_tensors_info_for_test (&info1, &info2);
  432. /* get size with invalid index */
  433. index = (gint) info1.num_tensors;
  434. size1 = gst_tensors_info_get_size (&info1, index);
  435. EXPECT_TRUE (size1 == 0);
  436. }
  437. /**
  438. * @brief Test for same tensors info.
  439. */
  440. TEST (common_tensor_info, equal_01_p)
  441. {
  442. GstTensorsInfo info1, info2;
  443. fill_tensors_info_for_test (&info1, &info2);
  444. EXPECT_TRUE (gst_tensors_info_is_equal (&info1, &info2));
  445. }
  446. /**
  447. * @brief Test for same tensors info.
  448. */
  449. TEST (common_tensor_info, equal_02_n)
  450. {
  451. GstTensorsInfo info1, info2;
  452. gst_tensors_info_init (&info1);
  453. gst_tensors_info_init (&info2);
  454. /* test with invalid info */
  455. EXPECT_FALSE (gst_tensors_info_is_equal (&info1, &info2));
  456. }
  457. /**
  458. * @brief Test for same tensors info.
  459. */
  460. TEST (common_tensor_info, equal_03_n)
  461. {
  462. GstTensorsInfo info1, info2;
  463. fill_tensors_info_for_test (&info1, &info2);
  464. /* change info, this should not be compatible */
  465. info1.num_tensors = 1;
  466. EXPECT_FALSE (gst_tensors_info_is_equal (&info1, &info2));
  467. }
  468. /**
  469. * @brief Test for same tensors info.
  470. */
  471. TEST (common_tensor_info, equal_04_n)
  472. {
  473. GstTensorsInfo info1, info2;
  474. fill_tensors_info_for_test (&info1, &info2);
  475. /* change info, this should not be compatible */
  476. info1.info[0].type = _NNS_UINT64;
  477. EXPECT_FALSE (gst_tensors_info_is_equal (&info1, &info2));
  478. }
  479. /**
  480. * @brief Test for same tensors info.
  481. */
  482. TEST (common_tensor_info, equal_05_n)
  483. {
  484. GstTensorsInfo info1, info2;
  485. fill_tensors_info_for_test (&info1, &info2);
  486. /* change info, this should not be compatible */
  487. info2.info[1].dimension[0] = 10;
  488. EXPECT_FALSE (gst_tensors_info_is_equal (&info1, &info2));
  489. }
  490. /**
  491. * @brief Test for same tensors config.
  492. */
  493. TEST (common_tensors_config, equal_01_p)
  494. {
  495. GstTensorsConfig conf1, conf2;
  496. fill_tensors_config_for_test (&conf1, &conf2);
  497. EXPECT_TRUE (gst_tensors_config_is_equal (&conf1, &conf2));
  498. }
  499. /**
  500. * @brief Test for same tensors config.
  501. */
  502. TEST (common_tensors_config, equal_02_p)
  503. {
  504. GstTensorsConfig conf1, conf2;
  505. fill_tensors_config_for_test (&conf1, &conf2);
  506. conf1.rate_n *= 2;
  507. conf1.rate_d *= 2;
  508. EXPECT_TRUE (gst_tensors_config_is_equal (&conf1, &conf2));
  509. }
  510. /**
  511. * @brief Test for same tensors config.
  512. */
  513. TEST (common_tensors_config, equal_03_p)
  514. {
  515. GstTensorsConfig conf1, conf2;
  516. fill_tensors_config_for_test (&conf1, &conf2);
  517. conf1.rate_n *= 0;
  518. conf2.rate_n *= 0;
  519. EXPECT_TRUE (gst_tensors_config_is_equal (&conf1, &conf2));
  520. }
  521. /**
  522. * @brief Test for same tensors config.
  523. */
  524. TEST (common_tensors_config, equal_04_n)
  525. {
  526. GstTensorsConfig conf1, conf2;
  527. gst_tensors_config_init (&conf1);
  528. gst_tensors_config_init (&conf2);
  529. EXPECT_FALSE (gst_tensors_config_is_equal (&conf1, &conf2));
  530. }
  531. /**
  532. * @brief Test for same tensors config.
  533. */
  534. TEST (common_tensors_config, equal_05_n)
  535. {
  536. GstTensorsConfig conf1, conf2;
  537. fill_tensors_config_for_test (&conf1, &conf2);
  538. conf1.rate_n *= 2;
  539. conf1.rate_d *= 4;
  540. EXPECT_FALSE (gst_tensors_config_is_equal (&conf1, &conf2));
  541. }
  542. /**
  543. * @brief Test for same tensors config.
  544. */
  545. TEST (common_tensors_config, equal_06_n)
  546. {
  547. GstTensorsConfig conf1, conf2;
  548. fill_tensors_config_for_test (&conf1, &conf2);
  549. conf1.rate_d *= 0;
  550. EXPECT_FALSE (gst_tensors_config_is_equal (&conf1, &conf2));
  551. }
  552. /**
  553. * @brief Test for dimensions string in tensors info.
  554. */
  555. TEST (common_tensors_info_string, dimensions)
  556. {
  557. GstTensorsInfo info;
  558. guint num_dims;
  559. gchar *str_dims;
  560. gst_tensors_info_init (&info);
  561. /* 1 tensor info */
  562. num_dims = gst_tensors_info_parse_dimensions_string (&info, "1:2:3:4");
  563. EXPECT_EQ (num_dims, 1U);
  564. info.num_tensors = num_dims;
  565. str_dims = gst_tensors_info_get_dimensions_string (&info);
  566. EXPECT_STREQ (str_dims, "1:2:3:4");
  567. g_free (str_dims);
  568. /* 4 tensors info */
  569. num_dims = gst_tensors_info_parse_dimensions_string (&info, "1, 2:2, 3:3:3, 4:4:4:4");
  570. EXPECT_EQ (num_dims, 4U);
  571. info.num_tensors = num_dims;
  572. str_dims = gst_tensors_info_get_dimensions_string (&info);
  573. EXPECT_STREQ (str_dims, "1:1:1:1,2:2:1:1,3:3:3:1,4:4:4:4");
  574. g_free (str_dims);
  575. /* max */
  576. num_dims = gst_tensors_info_parse_dimensions_string (&info,
  577. "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20");
  578. EXPECT_EQ (num_dims, (guint) NNS_TENSOR_SIZE_LIMIT);
  579. }
  580. /**
  581. * @brief Test for types string in tensors info.
  582. */
  583. TEST (common_tensors_info_string, types)
  584. {
  585. GstTensorsInfo info;
  586. guint num_types;
  587. gchar *str_types;
  588. gst_tensors_info_init (&info);
  589. /* 1 tensor info */
  590. num_types = gst_tensors_info_parse_types_string (&info, "uint16");
  591. EXPECT_EQ (num_types, 1U);
  592. info.num_tensors = num_types;
  593. str_types = gst_tensors_info_get_types_string (&info);
  594. EXPECT_STREQ (str_types, "uint16");
  595. g_free (str_types);
  596. /* 4 tensors info */
  597. num_types = gst_tensors_info_parse_types_string (&info,
  598. "int8, int16, int32, int64");
  599. EXPECT_EQ (num_types, 4U);
  600. info.num_tensors = num_types;
  601. str_types = gst_tensors_info_get_types_string (&info);
  602. EXPECT_STREQ (str_types, "int8,int16,int32,int64");
  603. g_free (str_types);
  604. /* max */
  605. num_types = gst_tensors_info_parse_types_string (&info,
  606. "int8, int8, int8, int8, int8, int8, int8, int8, int8, int8, int8, "
  607. "int8, int8, int8, int8, int8, int8, int8, int8, int8, int8, int8");
  608. EXPECT_EQ (num_types, (guint) NNS_TENSOR_SIZE_LIMIT);
  609. }
  610. /**
  611. * @brief Test for names string in tensors info.
  612. */
  613. TEST (common_tensors_info_string, names)
  614. {
  615. GstTensorsInfo info;
  616. guint i, num_names;
  617. gchar *str_names;
  618. gst_tensors_info_init (&info);
  619. /* 1 tensor info */
  620. num_names = gst_tensors_info_parse_names_string (&info, "t1");
  621. EXPECT_EQ (num_names, 1U);
  622. info.num_tensors = num_names;
  623. str_names = gst_tensors_info_get_names_string (&info);
  624. EXPECT_STREQ (str_names, "t1");
  625. g_free (str_names);
  626. /* 4 tensors info */
  627. num_names = gst_tensors_info_parse_names_string (&info,
  628. "tensor1, tensor2, tensor3, tensor4");
  629. EXPECT_EQ (num_names, 4U);
  630. info.num_tensors = num_names;
  631. str_names = gst_tensors_info_get_names_string (&info);
  632. EXPECT_STREQ (str_names, "tensor1,tensor2,tensor3,tensor4");
  633. g_free (str_names);
  634. /* empty name string */
  635. num_names = gst_tensors_info_parse_names_string (&info, ",,");
  636. EXPECT_EQ (num_names, 3U);
  637. info.num_tensors = num_names;
  638. for (i = 0; i < num_names; ++i) {
  639. EXPECT_TRUE (info.info[i].name == NULL);
  640. }
  641. str_names = gst_tensors_info_get_names_string (&info);
  642. EXPECT_STREQ (str_names, ",,");
  643. g_free (str_names);
  644. /* max */
  645. num_names = gst_tensors_info_parse_names_string (&info,
  646. "t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, "
  647. "t16, t17, t18, t19, t20, t21, t22, t23, t24, t25, t26, t27, t28");
  648. EXPECT_EQ (num_names, (guint) NNS_TENSOR_SIZE_LIMIT);
  649. }
  650. /**
  651. * @brief Test to replace string.
  652. */
  653. TEST (common_string_util, replace_str_01)
  654. {
  655. gchar *result;
  656. guint changed;
  657. result = g_strdup ("sourceelement ! parser ! converter ! format ! converter ! format ! converter ! sink");
  658. result = replace_string (result, "sourceelement", "src", NULL, &changed);
  659. EXPECT_EQ (changed, 1U);
  660. EXPECT_STREQ (result, "src ! parser ! converter ! format ! converter ! format ! converter ! sink");
  661. result = replace_string (result, "format", "fmt", NULL, &changed);
  662. EXPECT_EQ (changed, 2U);
  663. EXPECT_STREQ (result, "src ! parser ! converter ! fmt ! converter ! fmt ! converter ! sink");
  664. result = replace_string (result, "converter", "conv", NULL, &changed);
  665. EXPECT_EQ (changed, 3U);
  666. EXPECT_STREQ (result, "src ! parser ! conv ! fmt ! conv ! fmt ! conv ! sink");
  667. result = replace_string (result, "invalidname", "invalid", NULL, &changed);
  668. EXPECT_EQ (changed, 0U);
  669. EXPECT_STREQ (result, "src ! parser ! conv ! fmt ! conv ! fmt ! conv ! sink");
  670. g_free (result);
  671. }
  672. /**
  673. * @brief Test to replace string.
  674. */
  675. TEST (common_string_util, replace_str_02)
  676. {
  677. gchar *result;
  678. guint changed;
  679. result = g_strdup ("source! parser ! sources ! mysource ! source ! format !source! conv source");
  680. result = replace_string (result, "source", "src", " !", &changed);
  681. EXPECT_EQ (changed, 4U);
  682. EXPECT_STREQ (result, "src! parser ! sources ! mysource ! src ! format !src! conv src");
  683. result = replace_string (result, "src", "mysource", "! ", &changed);
  684. EXPECT_EQ (changed, 4U);
  685. EXPECT_STREQ (result, "mysource! parser ! sources ! mysource ! mysource ! format !mysource! conv mysource");
  686. result = replace_string (result, "source", "src", NULL, &changed);
  687. EXPECT_EQ (changed, 6U);
  688. EXPECT_STREQ (result, "mysrc! parser ! srcs ! mysrc ! mysrc ! format !mysrc! conv mysrc");
  689. result = replace_string (result, "mysrc", "src", ";", &changed);
  690. EXPECT_EQ (changed, 0U);
  691. EXPECT_STREQ (result, "mysrc! parser ! srcs ! mysrc ! mysrc ! format !mysrc! conv mysrc");
  692. g_free (result);
  693. }
  694. /**
  695. * @brief Create null files
  696. */
  697. static gchar *create_null_file (const gchar *dir, const gchar *file)
  698. {
  699. gchar *fullpath = g_build_path ("/", dir, file, NULL);
  700. FILE *fp = g_fopen (fullpath, "w");
  701. if (fp) {
  702. fclose (fp);
  703. } else {
  704. g_free (fullpath);
  705. return NULL;
  706. }
  707. return fullpath;
  708. }
  709. /**
  710. * @brief Check string custom conf
  711. */
  712. static gboolean check_custom_conf (const gchar *group, const gchar *key, const gchar *expected)
  713. {
  714. gchar *str = nnsconf_get_custom_value_string (group, key);
  715. gboolean ret = (0 == g_strcmp0 (str, expected));
  716. g_free (str);
  717. return ret;
  718. }
  719. /**
  720. * @brief Test custom configurations
  721. */
  722. TEST (conf_custom, env_str_01)
  723. {
  724. gchar *fullpath = g_build_path ("/", g_get_tmp_dir(), "nns-tizen-XXXXXX", NULL);
  725. gchar *dir = g_mkdtemp (fullpath);
  726. gchar *filename = g_build_path ("/", dir, "nnstreamer.ini", NULL);
  727. gchar *dirf = g_build_path ("/", dir, "filters", NULL);
  728. gchar *dircf = g_build_path ("/", dir, "custom", NULL);
  729. gchar *dird = g_build_path ("/", dir, "decoders", NULL);
  730. EXPECT_EQ (g_mkdir (dirf, 0755), 0);
  731. EXPECT_EQ (g_mkdir (dircf, 0755), 0);
  732. EXPECT_EQ (g_mkdir (dird, 0755), 0);
  733. FILE *fp = g_fopen (filename, "w");
  734. const gchar *fn;
  735. const gchar *base_confenv;
  736. gchar *confenv;
  737. ASSERT_TRUE (fp != NULL);
  738. base_confenv = g_getenv ("NNSTREAMER_CONF");
  739. confenv = (base_confenv != NULL) ? g_strdup (base_confenv) : NULL;
  740. g_fprintf (fp, "[common]\n");
  741. g_fprintf (fp, "enable_envvar=True\n");
  742. g_fprintf (fp, "[filter]\n");
  743. g_fprintf (fp, "filters=%s\n", dirf);
  744. g_fprintf (fp, "customfilters=%s\n", dircf);
  745. g_fprintf (fp, "[decoder]\n");
  746. g_fprintf (fp, "decoders=%s\n", dird);
  747. g_fprintf (fp, "[customX]\n");
  748. g_fprintf (fp, "abc=OFF\n");
  749. g_fprintf (fp, "def=on\n");
  750. g_fprintf (fp, "ghi=TRUE\n");
  751. g_fprintf (fp, "n01=fAlSe\n");
  752. g_fprintf (fp, "n02=yeah\n");
  753. g_fprintf (fp, "n03=NAH\n");
  754. g_fprintf (fp, "n04=1\n");
  755. g_fprintf (fp, "n05=0\n");
  756. g_fprintf (fp, "mzx=whatsoever\n");
  757. g_fprintf (fp, "[customY]\n");
  758. g_fprintf (fp, "mzx=dunno\n");
  759. g_fprintf (fp, "[customZ]\n");
  760. g_fprintf (fp, "mzx=wth\n");
  761. g_fprintf (fp, "n05=1\n");
  762. fclose (fp);
  763. gchar *f1 = create_null_file (dirf, "libnnstreamer_filter_fantastic"
  764. NNSTREAMER_SO_FILE_EXTENSION);
  765. gchar *f2 = create_null_file (dirf, "libnnstreamer_filter_neuralnetwork"
  766. NNSTREAMER_SO_FILE_EXTENSION);
  767. gchar *f3 = create_null_file (dird, "libnnstreamer_decoder_omg"
  768. NNSTREAMER_SO_FILE_EXTENSION);
  769. gchar *f4 = create_null_file (dird, "libnnstreamer_decoder_wthisgoingon"
  770. NNSTREAMER_SO_FILE_EXTENSION);
  771. gchar *f5 = create_null_file (dircf, "custom_mechanism"
  772. NNSTREAMER_SO_FILE_EXTENSION);
  773. gchar *f6 = create_null_file (dircf, "fastfaster"
  774. NNSTREAMER_SO_FILE_EXTENSION);
  775. EXPECT_TRUE (FALSE != g_setenv ("NNSTREAMER_CONF", filename, TRUE));
  776. EXPECT_TRUE (nnsconf_loadconf (TRUE) == TRUE);
  777. fn = nnsconf_get_fullpath ("fantastic", NNSCONF_PATH_FILTERS);
  778. EXPECT_STREQ (fn, f1);
  779. fn = nnsconf_get_fullpath ("neuralnetwork", NNSCONF_PATH_FILTERS);
  780. EXPECT_STREQ (fn, f2);
  781. fn = nnsconf_get_fullpath ("notfound", NNSCONF_PATH_FILTERS);
  782. EXPECT_STREQ (fn, NULL);
  783. fn = nnsconf_get_fullpath ("omg", NNSCONF_PATH_DECODERS);
  784. EXPECT_STREQ (fn, f3);
  785. fn = nnsconf_get_fullpath ("wthisgoingon", NNSCONF_PATH_DECODERS);
  786. EXPECT_STREQ (fn, f4);
  787. fn = nnsconf_get_fullpath ("notfound", NNSCONF_PATH_DECODERS);
  788. EXPECT_STREQ (fn, NULL);
  789. fn = nnsconf_get_fullpath ("custom_mechanism", NNSCONF_PATH_CUSTOM_FILTERS);
  790. EXPECT_STREQ (fn, f5);
  791. fn = nnsconf_get_fullpath ("fastfaster", NNSCONF_PATH_CUSTOM_FILTERS);
  792. EXPECT_STREQ (fn, f6);
  793. fn = nnsconf_get_fullpath ("notfound", NNSCONF_PATH_CUSTOM_FILTERS);
  794. EXPECT_STREQ (fn, NULL);
  795. EXPECT_TRUE (check_custom_conf ("customX", "abc", "OFF"));
  796. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customX", "abc", TRUE));
  797. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customX", "abc", FALSE));
  798. EXPECT_TRUE (check_custom_conf ("customX", "def", "on"));
  799. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "def", FALSE));
  800. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "def", TRUE));
  801. EXPECT_TRUE (check_custom_conf ("customX", "ghi", "TRUE"));
  802. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "ghi", FALSE));
  803. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "ghi", TRUE));
  804. EXPECT_TRUE (check_custom_conf ("customX", "n02", "yeah"));
  805. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "n02", FALSE));
  806. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "n02", TRUE));
  807. EXPECT_TRUE (check_custom_conf ("customX", "n03", "NAH"));
  808. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customX", "n03", FALSE));
  809. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customX", "n03", TRUE));
  810. EXPECT_TRUE (check_custom_conf ("customX", "n04", "1"));
  811. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "n04", FALSE));
  812. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "n04", TRUE));
  813. EXPECT_TRUE (check_custom_conf ("customX", "n05", "0"));
  814. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customX", "n05", FALSE));
  815. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customX", "n05", TRUE));
  816. EXPECT_TRUE (check_custom_conf ("customX", "mzx", "whatsoever"));
  817. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customX", "mzx", FALSE));
  818. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customX", "mzx", TRUE));
  819. EXPECT_TRUE (check_custom_conf ("customY", "mzx", "dunno"));
  820. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customY", "mzx", FALSE));
  821. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customY", "mzx", TRUE));
  822. EXPECT_TRUE (check_custom_conf ("customZ", "mzx", "wth"));
  823. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customZ", "mzx", FALSE));
  824. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customZ", "mzx", TRUE));
  825. EXPECT_TRUE (check_custom_conf ("customZ", "n05", "1"));
  826. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customZ", "n05", FALSE));
  827. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customZ", "n05", TRUE));
  828. EXPECT_TRUE (check_custom_conf ("customW", "n05", NULL));
  829. EXPECT_FALSE (nnsconf_get_custom_value_bool ("customW", "n05", FALSE));
  830. EXPECT_TRUE (nnsconf_get_custom_value_bool ("customW", "n05", TRUE));
  831. g_free (f1);
  832. g_free (f2);
  833. g_free (f3);
  834. g_free (f4);
  835. g_free (f5);
  836. g_free (f6);
  837. if (confenv) {
  838. EXPECT_TRUE (g_setenv ("NNSTREAMER_CONF", confenv, TRUE));
  839. g_free (confenv);
  840. } else {
  841. g_unsetenv ("NNSTREAMER_CONF");
  842. }
  843. }
  844. /**
  845. * @brief Test version control (positive)
  846. */
  847. TEST (version_control , get_ver_01)
  848. {
  849. gchar * verstr = nnstreamer_version_string();
  850. guint major, minor, micro;
  851. gchar * verstr2, * verstr3;
  852. nnstreamer_version_fetch (&major, &minor, &micro);
  853. verstr2 = g_strdup_printf ("NNStreamer %u.%u.%u", major, minor, micro);
  854. verstr3 = g_strdup_printf ("%u.%u.%u", major, minor, micro);
  855. EXPECT_STRCASEEQ (verstr, verstr2);
  856. EXPECT_STRCASEEQ (VERSION, verstr3);
  857. EXPECT_EQ ((int) major, NNSTREAMER_VERSION_MAJOR);
  858. EXPECT_EQ ((int) minor, NNSTREAMER_VERSION_MINOR);
  859. EXPECT_EQ ((int) micro, NNSTREAMER_VERSION_MICRO);
  860. g_free (verstr);
  861. g_free (verstr2);
  862. g_free (verstr3);
  863. }
  864. /**
  865. * @brief Main function for unit test.
  866. */
  867. int
  868. main (int argc, char **argv)
  869. {
  870. int ret = -1;
  871. try {
  872. testing::InitGoogleTest (&argc, argv);
  873. } catch (...) {
  874. g_warning ("catch 'testing::internal::<unnamed>::ClassUniqueToAlwaysTrue'");
  875. }
  876. try {
  877. ret = RUN_ALL_TESTS ();
  878. } catch (...) {
  879. g_warning ("catch `testing::internal::GoogleTestFailureException`");
  880. }
  881. return ret;
  882. }