API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 28th, 2016
60
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 17.00 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. @name: Jake Ojero
  3. @date: September, 26th, 2016
  4. @purpose: Test the Sorted Vector header file using BOOST Unit Tests
  5.  
  6. */
  7. #define BOOST_TEST_MODULE SortedVectorTest
  8. #define _SCL_SECURE_NO_WARNINGS
  9. #include <boost\test\unit_test.hpp>
  10. #include <boost\mpl\list.hpp>
  11. #include <iostream>
  12. #include <string>
  13. #include <stdlib.h> /* srand, rand */
  14. #include <time.h>
  15. using namespace std;
  16.  
  17.  
  18. #include "sorted_vector.hpp"
  19.  
  20. typedef boost::mpl::list<short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, double, float> test_types;
  21.  
  22. /* Intro */
  23. BOOST_AUTO_TEST_CASE(intro) {
  24. cout << "\nSorted Vector Test. \n";
  25. cout << "Last compiled: " << __TIMESTAMP__ << "\n\n";
  26. }
  27.  
  28. /***********************************************
  29.  
  30. CONSTRUCTORS
  31.  
  32. ************************************************/
  33.  
  34.  
  35. /* DONE */
  36. BOOST_AUTO_TEST_CASE_TEMPLATE(default_constructor_test, T, test_types) {
  37. sorted_vector<T> v;
  38. BOOST_CHECK_EQUAL(v.size(), 0);
  39. BOOST_CHECK(v.empty());
  40. }
  41.  
  42. /* DONE */
  43. BOOST_AUTO_TEST_CASE_TEMPLATE(elements_constructor_test, T, test_types) {
  44. sorted_vector<T> v(10);
  45. BOOST_CHECK(!v.empty());
  46. BOOST_CHECK(v.begin() != nullptr);
  47. BOOST_CHECK_EQUAL(v.size(), 10);
  48. BOOST_CHECK_EQUAL(v.end(), v.begin() + 10);
  49. BOOST_CHECK_EQUAL(v.capacity(), 10);
  50. for (size_t i = 0; i < v.size(); ++i) {
  51. BOOST_CHECK_EQUAL(v.at(i), 0);
  52. }
  53.  
  54. // Check for a given value of 1 instead of using default #
  55. sorted_vector<T> v2(10,1);
  56. BOOST_CHECK(!v2.empty());
  57. BOOST_CHECK(v2.begin() != nullptr);
  58. BOOST_CHECK_EQUAL(v2.size(), 10);
  59. BOOST_CHECK_EQUAL(v2.end(), v2.begin() + 10);
  60. BOOST_CHECK_EQUAL(v2.capacity(), 10);
  61. for (size_t i = 0; i < v2.size(); ++i) {
  62. BOOST_CHECK_EQUAL(v2.at(i), 1);
  63. }
  64. }
  65.  
  66. /* DONE */
  67. BOOST_AUTO_TEST_CASE_TEMPLATE(copy_constructor_test, T, test_types) {
  68. sorted_vector<T> v1;
  69. T num = 1;
  70. for (size_t i = 1; i <= 10; ++i) {
  71. v1.insert(num++);
  72. BOOST_CHECK(!v1.empty());
  73. BOOST_CHECK_EQUAL(v1.size(), i);
  74. BOOST_REQUIRE_EQUAL(v1.end(), v1.begin() + i);
  75. BOOST_CHECK_EQUAL(*(v1.end() -1), i);
  76. }
  77.  
  78. BOOST_CHECK(v1.begin() != nullptr);
  79. BOOST_CHECK(v1.end() != nullptr);
  80. BOOST_CHECK_MESSAGE(check_sorted(v1), "Vector [v1] is not sorted correctly");
  81.  
  82. sorted_vector<T> v2(v1);
  83.  
  84. BOOST_CHECK(v2.begin() != nullptr);
  85. BOOST_CHECK(v2.begin() != nullptr);
  86. BOOST_CHECK_MESSAGE(check_sorted(v2), "Vector [v2] is not sorted correctly");
  87.  
  88. BOOST_CHECK_EQUAL(v1.size(), v2.size());
  89. BOOST_CHECK_EQUAL(v2.end(), v2.begin() + v1.size());
  90. for (size_t i = 10; i >= 1; --i) {
  91. BOOST_CHECK(!v2.empty());
  92. BOOST_CHECK_EQUAL(*(v1.end() - 1), *(v2.end() - 1));
  93. BOOST_CHECK_EQUAL(v1.size(), i);
  94.  
  95. v1.erase(v1.end()-1);
  96. v2.erase(v2.end()-1);
  97. }
  98.  
  99. BOOST_CHECK(v1.empty());
  100. BOOST_CHECK(v2.empty());
  101.  
  102.  
  103. }
  104.  
  105. /* DONE */
  106. BOOST_AUTO_TEST_CASE_TEMPLATE(move_constructor_test, T, test_types) {
  107.  
  108. sorted_vector<T> v1;
  109. T num = 1;
  110. for (size_t i = 1; i <= 10; ++i) {
  111. v1.insert(num++);
  112. BOOST_CHECK(!v1.empty());
  113. BOOST_CHECK_EQUAL(v1.size(), i);
  114. BOOST_CHECK_EQUAL(*(v1.end() - 1), i);
  115. }
  116.  
  117. BOOST_CHECK_MESSAGE(check_sorted(v1), "Vector [v1] is not sorted correctly");
  118.  
  119. auto beg = v1.begin();
  120. auto end = v1.end();
  121. auto cap = v1.capacity();
  122.  
  123. sorted_vector<T> v2(move(v1));
  124. BOOST_CHECK(v1.empty());
  125. BOOST_CHECK_EQUAL(v2.begin(), beg);
  126. BOOST_CHECK_EQUAL(v2.end(), end);
  127. BOOST_CHECK_EQUAL(v2.capacity(), cap);
  128. BOOST_CHECK(v1.begin() == nullptr);
  129. BOOST_CHECK(v1.end() == nullptr);
  130. BOOST_CHECK_MESSAGE(check_sorted(v2), "Vector [v2] is not sorted correctly");
  131.  
  132.  
  133. }
  134.  
  135. /* DONE */
  136. BOOST_AUTO_TEST_CASE_TEMPLATE(iterator_constructor_test, T, test_types) {
  137. sorted_vector<T> sv;
  138. T num = 1;
  139. for (size_t i = 1; i <= 10; ++i) {
  140. sv.insert(num++);
  141. BOOST_CHECK(!sv.empty());
  142. BOOST_CHECK_EQUAL(sv.size(), i);
  143. }
  144.  
  145. BOOST_CHECK_MESSAGE(check_sorted(sv), "Vector [sv] is not sorted correctly");
  146.  
  147. BOOST_CHECK(sv.begin() != nullptr);
  148. BOOST_CHECK(sv.end() != nullptr);
  149.  
  150. sorted_vector<T> dsv(sv.begin(), sv.end());
  151. BOOST_CHECK_EQUAL(dsv.end(), dsv.begin() + 10);
  152. BOOST_CHECK(dsv.begin() != nullptr);
  153. BOOST_CHECK(dsv.end() != nullptr);
  154. BOOST_CHECK_MESSAGE(check_sorted(dsv), "Vector [dsv] is not sorted correctly");
  155. for (size_t i = 0; i < 10; ++i) {
  156. BOOST_CHECK_EQUAL(dsv.at(i), sv.at(i));
  157. }
  158.  
  159. // Check when an unsorted vector is passed, that it gets sorted;
  160. sorted_vector<T> sv2(10);
  161. T a[10] = { 3, 4, 1, 7, 5, 8, 6, 9, 10 , 2};
  162.  
  163. for (size_t i = 0; i < 10; ++i) {
  164.  
  165. sv2[i] = a[i];
  166. }
  167. BOOST_CHECK(sv2.begin() != nullptr);
  168. BOOST_CHECK(sv2.end() != nullptr);
  169. BOOST_CHECK_EQUAL(sv2.size(), 10);
  170.  
  171. sorted_vector<T> iterCopy(sv2.begin(), sv2.end());
  172. BOOST_CHECK_MESSAGE(check_sorted(iterCopy), "Vector [iterCopy] is not sorted correctly");
  173.  
  174. }
  175.  
  176.  
  177. /***********************************************
  178.  
  179. METHODS
  180.  
  181. ************************************************/
  182.  
  183. /* DONE */
  184. BOOST_AUTO_TEST_CASE_TEMPLATE(find_method_test, T, test_types) {
  185. sorted_vector<T> v;
  186. T num = 1;
  187. for (size_t i = 1; i <= 10; ++i) {
  188. v.insert(num++);
  189. BOOST_CHECK(!v.empty());
  190. BOOST_CHECK_EQUAL(v.size(), i);
  191. BOOST_CHECK_EQUAL(*(v.end() - 1), i);
  192. }
  193. BOOST_REQUIRE_MESSAGE(v.begin() != nullptr, "begin() is equal to nullptr");
  194. BOOST_REQUIRE_MESSAGE(v.end() != nullptr, "end() is equal to nullptr");
  195.  
  196. // Check that it is sorted
  197. BOOST_CHECK_MESSAGE( check_sorted(v), "Vector [v] in find() is not sorted correctly" );
  198.  
  199. // Check that find returns a number inside of the vector
  200. auto numReturned = v.find(6);
  201. BOOST_CHECK(numReturned != nullptr);
  202. BOOST_CHECK(numReturned <= v.end());
  203. BOOST_CHECK(numReturned >= v.begin());
  204. BOOST_CHECK_EQUAL(*numReturned, 6);
  205.  
  206. // 15 not in vector should return v.end()
  207. auto numReturned2 = v.find(15);
  208. BOOST_CHECK(numReturned2 != nullptr);
  209. BOOST_CHECK_EQUAL(numReturned2, v.end());
  210.  
  211. }
  212.  
  213. /* DONE */
  214. BOOST_AUTO_TEST_CASE_TEMPLATE(at_method_test, T, test_types) {
  215.  
  216. sorted_vector<T> v;
  217. T num = 1;
  218. for (size_t i = 1; i <= 10; ++i) {
  219. v.insert(num++);
  220. BOOST_CHECK(!v.empty());
  221. BOOST_CHECK_EQUAL(v.size(), i);
  222. BOOST_CHECK_EQUAL(*(v.end() - 1), i);
  223. }
  224. BOOST_CHECK_MESSAGE(check_sorted(v), "Vector is not sorted correctly");
  225.  
  226. size_t index = 10;
  227. BOOST_CHECK_THROW(v.at(index), std::out_of_range);
  228. index = 5;
  229. auto numRef = v.at(index);
  230. BOOST_CHECK_EQUAL(numRef, *(v.begin() + index));
  231.  
  232.  
  233. }
  234.  
  235. /* DONE */
  236. BOOST_AUTO_TEST_CASE_TEMPLATE(erase_method_test, T, test_types) {
  237.  
  238. sorted_vector<T> v;
  239. sorted_vector<T> v2;
  240. T num = 1;
  241. for (size_t i = 1; i <= 10; ++i) {
  242. v.insert(num);
  243. v2.insert(num++);
  244. BOOST_CHECK(!v.empty());
  245. BOOST_CHECK_EQUAL(v.size(), i);
  246. BOOST_CHECK_EQUAL(*(v.end() - 1), i);
  247. BOOST_CHECK(!v2.empty());
  248. BOOST_CHECK_EQUAL(v2.size(), i);
  249. BOOST_CHECK_EQUAL(*(v2.end() - 1), i);
  250. }
  251. BOOST_CHECK_MESSAGE(v.begin() != nullptr, "v begin() iterator is null");
  252. BOOST_CHECK_MESSAGE(v.end() != nullptr, "v end() iterator is null");
  253. BOOST_CHECK_MESSAGE(check_sorted(v), "Vector [v] is not sorted correctly");
  254. BOOST_CHECK_MESSAGE(v2.begin() != nullptr, "v2 begin() iterator is null");
  255. BOOST_CHECK_MESSAGE(v2.end() != nullptr, "v2 end() iterator is null");
  256. BOOST_CHECK_MESSAGE(check_sorted(v2), "Vector [v2] is not sorted correctly");
  257.  
  258.  
  259. auto startend = v.end();
  260. auto startendv2 = v2.end();
  261. BOOST_CHECK(startend != nullptr);
  262. BOOST_CHECK(startendv2 != nullptr);
  263.  
  264. auto locationToErase = v.begin() + 5;
  265. BOOST_REQUIRE_MESSAGE(locationToErase < v.end() && locationToErase >= v.begin(), "Location being erased is not in vector [v], accessing invalid data");
  266. auto locationToErase2 = v2.begin() + 5;
  267. BOOST_REQUIRE_MESSAGE(locationToErase2 < v2.end() && locationToErase2 >= v2.begin(), "Location being erased is not in vector [v2], accessing invalid data");
  268.  
  269.  
  270. auto numberErased = v.erase(locationToErase);
  271. auto numberErased2 = v2.erase(locationToErase2);
  272. BOOST_CHECK_MESSAGE(numberErased != nullptr, "Position erased is null");
  273. BOOST_CHECK_MESSAGE(numberErased2 != nullptr, "Position erased is null");
  274. BOOST_CHECK_MESSAGE(check_sorted(v), "Vector [v] is not sorted correctly");
  275. BOOST_CHECK_MESSAGE(check_sorted(v2), "Vector [v2] is not sorted correctly");
  276. BOOST_CHECK_EQUAL(numberErased, locationToErase);
  277. BOOST_CHECK_EQUAL(numberErased2, locationToErase2);
  278.  
  279. BOOST_CHECK(v.cbegin() != nullptr);
  280. BOOST_CHECK(v.cend() != nullptr);
  281. BOOST_CHECK(v2.cbegin() != nullptr);
  282.  
  283. auto result = v == v2;
  284. auto equalResult = gats::equal(v.cbegin(), v.cend(), v2.cbegin());
  285. BOOST_CHECK(result == true || result == false);
  286. BOOST_CHECK(equalResult == true || equalResult == false);
  287. BOOST_CHECK_EQUAL(v.size(), v2.size());
  288. BOOST_CHECK_EQUAL(equalResult, true);
  289. BOOST_CHECK_EQUAL(result, true);
  290. BOOST_CHECK_EQUAL(result, equalResult);
  291. BOOST_CHECK(v.end() != startend);
  292. BOOST_CHECK(v2.end() != startendv2);
  293.  
  294. }
  295.  
  296. /* DONE */
  297. BOOST_AUTO_TEST_CASE_TEMPLATE(insert_method_test, T, test_types) {
  298. sorted_vector<T> v1;
  299. T num = 1;
  300.  
  301. for (size_t i = 1; i <= 10; ++i) {
  302. auto it = v1.insert(num++);
  303. BOOST_CHECK(!v1.empty());
  304. BOOST_CHECK(v1.begin() != nullptr);
  305. BOOST_CHECK(v1.end() != nullptr);
  306. BOOST_CHECK_EQUAL(v1.size(), i);
  307. BOOST_CHECK_EQUAL(*(v1.end() - 1), i);
  308. BOOST_CHECK(v1.size() <= v1.capacity());
  309. BOOST_CHECK_MESSAGE(it != nullptr, "Error: iterator for postition inserted is equal to nullptr");
  310. BOOST_CHECK_EQUAL(it, v1.end() - 1);
  311. }
  312.  
  313. //Check insert point is in correct space
  314. auto it = v1.insert(4);
  315. BOOST_CHECK_MESSAGE(*it == 4, "Insert point value is incorrect" << " [" << *it << " != " << "4]");
  316. BOOST_CHECK_MESSAGE(*(v1.end() - 1) == 10, "end iterator's value was modified instead of the insertPoint's" << " [" << *(v1.end() - 1) << " != " << 10 << "]");
  317. BOOST_CHECK_MESSAGE(check_sorted(v1), "Vector is not sorted correctly");
  318.  
  319. }
  320.  
  321.  
  322. /***********************************************
  323.  
  324. OPERATORS
  325.  
  326. ************************************************/
  327.  
  328.  
  329. /* DONE */
  330. BOOST_AUTO_TEST_CASE_TEMPLATE(assign_test, T, test_types) {
  331.  
  332. sorted_vector<T> sv;
  333. sorted_vector<T> dsv;
  334. T num = 1;
  335. for (size_t i = 1; i <= 10; ++i) {
  336. sv.insert(num + 100);
  337. dsv.insert(num + 200);
  338. }
  339. BOOST_CHECK(!sv.empty());
  340. BOOST_CHECK_EQUAL(sv.size(), 10);
  341. BOOST_CHECK(!dsv.empty());
  342. BOOST_CHECK_EQUAL(dsv.size(), 10);
  343. BOOST_CHECK_MESSAGE(check_sorted(sv), "Vector is not sorted correctly");
  344. BOOST_CHECK_MESSAGE(check_sorted(dsv), "Vector is not sorted correctly");
  345.  
  346. dsv = sv;
  347.  
  348. BOOST_CHECK(!dsv.empty());
  349. BOOST_CHECK(!sv.empty());
  350. BOOST_CHECK(dsv.begin() != nullptr);
  351. BOOST_CHECK(dsv.end() != nullptr);
  352. BOOST_CHECK_EQUAL(dsv.end(), dsv.begin() + sv.size());
  353.  
  354. for (size_t i = 0; i < 10; ++i) {
  355. BOOST_CHECK(!dsv.empty());
  356. BOOST_CHECK_EQUAL(*dsv.begin(), *sv.begin());
  357. BOOST_CHECK_EQUAL(dsv.size(), dsv.end() - dsv.begin());
  358. dsv.erase(dsv.begin());
  359. sv.erase(sv.begin());
  360. }
  361.  
  362. // Different Sizes
  363. sorted_vector<T> sv2;
  364. sorted_vector<T> dsv2;
  365. T num2 = 1;
  366. for (size_t i = 1; i <= 10; ++i) {
  367. sv2.insert(num2 + 100);
  368. }
  369. dsv2.insert(num2 + 200);
  370.  
  371. BOOST_CHECK(!sv2.empty());
  372. BOOST_CHECK_EQUAL(sv2.size(), 10);
  373. BOOST_CHECK(!dsv2.empty());
  374. BOOST_CHECK_EQUAL(dsv2.size(), 1);
  375. BOOST_CHECK_MESSAGE(check_sorted(sv2), "Vector [sv2] is not sorted correctly");
  376. BOOST_CHECK_MESSAGE(check_sorted(dsv2), "Vector [dsv2] is not sorted correctly");
  377.  
  378. dsv2 = sv2;
  379.  
  380. BOOST_CHECK(!dsv2.empty());
  381. BOOST_CHECK(!sv2.empty());
  382. BOOST_CHECK(dsv2.begin() != nullptr);
  383. BOOST_CHECK(dsv2.end() != nullptr);
  384. BOOST_CHECK_EQUAL(dsv2.end(), dsv2.begin() + sv2.size());
  385. BOOST_CHECK_MESSAGE(dsv2.capacity() == sv2.size(), "Capacity pointer error, capacity() should be equal to begin() + size()" << " [" << dsv2.capacity() << " != " << sv2.size() << "]");
  386. BOOST_CHECK_EQUAL(dsv2.size(), sv2.size());
  387. }
  388.  
  389. /* DONE */
  390. BOOST_AUTO_TEST_CASE_TEMPLATE(assign_move_test, T, test_types) {
  391. sorted_vector<T> sv;
  392. sorted_vector<T> dsv;
  393. T num = 1;
  394. for (size_t i = 1; i <= 10; ++i) {
  395. sv.insert(num + 100);
  396. dsv.insert(num + 200);
  397. }
  398.  
  399. BOOST_CHECK(!sv.empty());
  400. BOOST_CHECK_EQUAL(sv.size(), 10);
  401. BOOST_CHECK(!dsv.empty());
  402. BOOST_CHECK_EQUAL(dsv.size(), 10);
  403. BOOST_CHECK_MESSAGE(check_sorted(sv), "Vector is not sorted correctly");
  404. BOOST_CHECK_MESSAGE(check_sorted(dsv), "Vector is not sorted correctly");
  405.  
  406. auto beg = sv.begin();
  407. auto end = sv.end();
  408. auto cap = sv.capacity();
  409.  
  410. dsv = move(sv);
  411.  
  412. BOOST_CHECK(sv.empty());
  413. BOOST_CHECK(sv.begin() == nullptr);
  414. BOOST_CHECK(sv.end() == nullptr);
  415. BOOST_CHECK_EQUAL(dsv.begin(), beg);
  416. BOOST_CHECK_EQUAL(dsv.end(), end);
  417. BOOST_CHECK_EQUAL(dsv.capacity(), cap);
  418.  
  419. for (size_t i = 0; i < 10; ++i) {
  420. BOOST_CHECK(!dsv.empty());
  421. BOOST_CHECK_EQUAL(dsv.size(), dsv.end() - dsv.begin());
  422. dsv.erase(dsv.begin());
  423. }
  424. BOOST_CHECK(dsv.empty());
  425.  
  426. // test chaining
  427. sorted_vector<T> ddsv;
  428. T num2 = 1;
  429. for (size_t i = 1; i <= 10; ++i) {
  430. sv.insert(num2 + 100);
  431. dsv.insert(num2 + 200);
  432. }
  433.  
  434. ddsv = dsv = move(sv);
  435.  
  436. BOOST_CHECK(sv.begin() == nullptr);
  437. BOOST_CHECK(sv.end() == nullptr);
  438.  
  439. BOOST_CHECK(!ddsv.empty());
  440. BOOST_CHECK_EQUAL(ddsv.size(), 10);
  441. BOOST_CHECK(ddsv.begin() != nullptr);
  442. BOOST_CHECK(ddsv.end() != nullptr);
  443.  
  444.  
  445.  
  446. }
  447.  
  448. /* DONE */
  449. BOOST_AUTO_TEST_CASE_TEMPLATE(equality_test, T, test_types) {
  450. sorted_vector<T> sv;
  451. sorted_vector<T> dsv;
  452. T num = 1;
  453. for (size_t i = 1; i <= 10; ++i) {
  454. sv.insert(num + 100);
  455. dsv.insert(num + 100);
  456. }
  457. BOOST_CHECK(!sv.empty());
  458. BOOST_CHECK_EQUAL(sv.size(), 10);
  459. BOOST_CHECK(!dsv.empty());
  460. BOOST_CHECK_EQUAL(dsv.size(), 10);
  461. BOOST_CHECK(dsv.cbegin() != nullptr);
  462. BOOST_CHECK(dsv.cend() != nullptr);
  463. BOOST_CHECK(sv.cbegin() != nullptr);
  464. BOOST_CHECK_MESSAGE(check_sorted(sv), "Vector is not sorted correctly");
  465. BOOST_CHECK_MESSAGE(check_sorted(dsv), "Vector is not sorted correctly");
  466.  
  467. bool result = dsv == sv;
  468. bool equalResult = gats::equal(dsv.cbegin(), dsv.cend(), sv.cbegin());
  469.  
  470.  
  471. BOOST_CHECK(equalResult == true || equalResult == false);
  472. BOOST_CHECK(result == true || result == false);
  473. BOOST_CHECK_EQUAL(dsv.size(), sv.size());
  474. BOOST_CHECK_EQUAL(equalResult, true);
  475. BOOST_CHECK_EQUAL(result, true);
  476. BOOST_CHECK_EQUAL(result, equalResult);
  477.  
  478.  
  479. }
  480.  
  481. /* DONE */
  482. BOOST_AUTO_TEST_CASE_TEMPLATE(not_equal_test, T, test_types) {
  483. sorted_vector<T> sv;
  484. sorted_vector<T> dsv;
  485. T num = 1;
  486. for (size_t i = 1; i <= 10; ++i) {
  487. sv.insert(num + 100);
  488. dsv.insert(num + 200);
  489. }
  490.  
  491. BOOST_CHECK(!sv.empty());
  492. BOOST_CHECK_EQUAL(sv.size(), 10);
  493. BOOST_CHECK(!dsv.empty());
  494. BOOST_CHECK_EQUAL(dsv.size(), 10);
  495. BOOST_CHECK(dsv.cbegin() != nullptr);
  496. BOOST_CHECK(dsv.cend() != nullptr);
  497. BOOST_CHECK(sv.cbegin() != nullptr);
  498. BOOST_CHECK_MESSAGE(check_sorted(sv), "Vector is not sorted correctly");
  499. BOOST_CHECK_MESSAGE(check_sorted(dsv), "Vector is not sorted correctly");
  500.  
  501. bool result = dsv != sv;
  502. bool GATS_equalResult = gats::equal(dsv.cbegin(), dsv.cend(), sv.cbegin());
  503.  
  504. BOOST_CHECK(GATS_equalResult == true || GATS_equalResult == false);
  505. BOOST_CHECK(result == true || result == false);
  506. BOOST_CHECK_EQUAL(dsv.size(), sv.size());
  507. BOOST_CHECK_EQUAL(GATS_equalResult, false);
  508. BOOST_CHECK_EQUAL(result, true);
  509.  
  510.  
  511. // If Equal make sure result returns true
  512. for (auto &a : sv)
  513. a = 5;
  514.  
  515. for (auto& a : dsv)
  516. a = 5;
  517.  
  518. bool result2 = dsv != sv;
  519. bool GATS_equalResult2 = gats::equal(dsv.cbegin(), dsv.cend(), sv.cbegin());
  520. BOOST_CHECK(GATS_equalResult2 == true || GATS_equalResult2 == false);
  521. BOOST_CHECK(result2 == true || result2 == false);
  522. BOOST_CHECK_EQUAL(dsv.size(), sv.size());
  523. BOOST_CHECK_EQUAL(GATS_equalResult2, true);
  524. BOOST_CHECK_EQUAL(result2, false);
  525.  
  526. }
  527.  
  528.  
  529. /***********************************************
  530.  
  531. Other Tests
  532.  
  533. ************************************************/
  534.  
  535. BOOST_AUTO_TEST_CASE_TEMPLATE(capacity_test, T, test_types) {
  536. sorted_vector<T> v;
  537. T num = 1;
  538. for (size_t i = 1; i <= 10; ++i) {
  539. v.insert(num + 100);
  540. BOOST_CHECK(!v.empty());
  541. BOOST_CHECK_EQUAL(v.size(), i);
  542. }
  543.  
  544. BOOST_CHECK_EQUAL(v.capacity(), 16);
  545. }
  546.  
  547. BOOST_AUTO_TEST_CASE_TEMPLATE(end_test, T, test_types) {
  548. sorted_vector<T> v;
  549. T num = 1;
  550. for (size_t i = 1; i <= 10; ++i) {
  551. v.insert(num + 100);
  552. BOOST_CHECK(!v.empty());
  553. BOOST_CHECK_EQUAL(v.size(), i);
  554. }
  555.  
  556. BOOST_CHECK_EQUAL(v.end(), v.begin() + 10);
  557. }
  558.  
  559. BOOST_AUTO_TEST_CASE_TEMPLATE(reverse_iter_test, T, test_types) {
  560. sorted_vector<T> v;
  561. T num = 1;
  562. for (size_t i = 1; i <= 10; ++i) {
  563. v.insert(num++ + 100);
  564. BOOST_CHECK(!v.empty());
  565. BOOST_CHECK_EQUAL(v.size(), i);
  566. }
  567.  
  568. auto rbeg = v.rbegin();
  569. auto rend = v.rend();
  570. auto beg = v.begin();
  571. auto end = v.end()-1;
  572.  
  573. for (; rbeg != rend; ++rbeg, --end) {
  574. BOOST_CHECK_EQUAL(*rbeg, *end);
  575. }
  576.  
  577. }
  578.  
  579. template <typename T>
  580. boost::test_tools::predicate_result check_sorted(sorted_vector<T> v) {
  581. auto beg = v.begin();
  582. auto end = v.end();
  583. auto next = beg+1;
  584. auto endNums = end - 1;
  585.  
  586. for (; beg != endNums; ++beg, ++next) {
  587. if (*beg > *next) {
  588. // failed
  589. boost::test_tools::predicate_result res(false);
  590. res.message() << "[" << *beg << " > " << *next << "]";
  591. return res;
  592. }
  593.  
  594. }
  595.  
  596. return true;
  597.  
  598. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!