HandleTest.cpp 2.0 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879
  1. 
  2. #include "../testTools.h"
  3. #include "../../DFPSR/base/Handle.h"
  4. static int64_t countA = 0;
  5. static int64_t countB = 0;
  6. static int64_t countC = 0;
  7. struct TypeA {
  8. int32_t value;
  9. TypeA(int32_t value) : value(value) {
  10. countA++;
  11. }
  12. ~TypeA() {
  13. countA--;
  14. }
  15. };
  16. struct TypeB {
  17. Handle<TypeA> left;
  18. Handle<TypeA> right;
  19. TypeB() { countB++; }
  20. TypeB(const Handle<TypeA> &left) : left(left) { countB++; }
  21. TypeB(const Handle<TypeA> &left, const Handle<TypeA> &right) : left(left), right(right) { countB++; }
  22. ~TypeB() { countB--; }
  23. };
  24. struct TypeC {
  25. Handle<TypeA> x;
  26. Handle<TypeB> y;
  27. TypeC() { countC++; }
  28. TypeC(const Handle<TypeA> &x) : x(x) { countC++; }
  29. TypeC(const Handle<TypeA> &x, const Handle<TypeB> &y) : x(x), y(y) { countC++; }
  30. ~TypeC() { countC--; }
  31. };
  32. START_TEST(Handle)
  33. {
  34. ASSERT_EQUAL(countA, 0);
  35. ASSERT_EQUAL(countB, 0);
  36. ASSERT_EQUAL(countC, 0);
  37. {
  38. TypeA valueA = 35;
  39. ASSERT_EQUAL(countA, 1);
  40. ASSERT_EQUAL(countB, 0);
  41. ASSERT_EQUAL(countC, 0);
  42. ASSERT_EQUAL(valueA.value, 35);
  43. {
  44. TypeB pairB = TypeB(handle_create<TypeA>(5), handle_create<TypeA>(8));
  45. ASSERT_EQUAL(countA, 3);
  46. ASSERT_EQUAL(countB, 1);
  47. ASSERT_EQUAL(countC, 0);
  48. ASSERT_EQUAL(pairB.left->value, 5);
  49. ASSERT_EQUAL(pairB.right->value, 8);
  50. {
  51. TypeC trio = TypeC(handle_create<TypeA>(1), handle_create<TypeB>(handle_create<TypeA>(2), handle_create<TypeA>(3)));
  52. ASSERT_EQUAL(countA, 6);
  53. ASSERT_EQUAL(countB, 2);
  54. ASSERT_EQUAL(countC, 1);
  55. ASSERT_EQUAL(trio.x->value, 1);
  56. ASSERT_EQUAL(trio.y->left->value, 2);
  57. ASSERT_EQUAL(trio.y->right->value, 3);
  58. }
  59. ASSERT_EQUAL(countA, 3);
  60. ASSERT_EQUAL(countB, 1);
  61. ASSERT_EQUAL(countC, 0);
  62. ASSERT_EQUAL(pairB.left->value, 5);
  63. ASSERT_EQUAL(pairB.right->value, 8);
  64. }
  65. ASSERT_EQUAL(countA, 1);
  66. ASSERT_EQUAL(countB, 0);
  67. ASSERT_EQUAL(countC, 0);
  68. ASSERT_EQUAL(valueA.value, 35);
  69. }
  70. ASSERT_EQUAL(countA, 0);
  71. ASSERT_EQUAL(countB, 0);
  72. ASSERT_EQUAL(countC, 0);
  73. }
  74. END_TEST