PageRenderTime 46ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/trunk/Examples/test-suite/perl5/operator_overload_runme.pl

#
Perl | 175 lines | 104 code | 37 blank | 34 comment | 4 complexity | 60e878d6fbb668b1c6e3a226f87966ff MD5 | raw file
Possible License(s): LGPL-2.1, Cube, GPL-3.0, 0BSD, GPL-2.0
  1. #!/usr/bin/perl -w
  2. use strict;
  3. use Test::More tests => 39;
  4. use operator_overload;
  5. # Workaround for
  6. # ok( not (expression) , "test description" );
  7. # does not working in older versions of Perl, eg 5.004_04
  8. sub ok_not ($;$) {
  9. my($test, $name) = @_;
  10. $test = not $test;
  11. ok($test, $name);
  12. }
  13. pass("loaded");
  14. # first check all the operators are implemented correctly from pure C++ code
  15. operator_overloadc::Op_sanity_check();
  16. my $op = operator_overload::Op->new();
  17. isa_ok($op, "operator_overload::Op");
  18. my $op2 = operator_overload::Op->new();
  19. isa_ok($op2, "operator_overload::Op");
  20. # operator equal
  21. $op->{i} = 5;
  22. $op2->{i} = 3;
  23. ok_not(($op == $op2), "operator equal: not equal");
  24. $op->{i} = 3;
  25. ok(($op == $op2), "operator equal: equal");
  26. # operator not equal
  27. $op->{i} = 5;
  28. $op2->{i} = 3;
  29. ok(($op != $op2), "operator not equal: not equal");
  30. $op->{i} = 3;
  31. ok_not(($op != $op2), "operator not equal: equal");
  32. # stringify operator
  33. $op->{i} = 3;
  34. is("Op(3)", "$op", "operator stringify");
  35. # addition operator
  36. $op->{i} = 3;
  37. $op2->{i} = 3;
  38. my $op3 = $op + $op2;
  39. is($op3->{i}, 6, "operator addition");
  40. # addition assignment operator
  41. $op->{i} = 3;
  42. $op2->{i} = 3;
  43. $op += $op2;
  44. is($op->{i}, 6, "operator additive assignment");
  45. # subtraction operator
  46. $op3->{i} = 6;
  47. $op2->{i} = 3;
  48. $op = $op3 - $op2;
  49. is($op->{i}, 3, "operator subtraction");
  50. # reversed subtraction operator (with int)
  51. $op3->{i} = 3;
  52. $op = 6 - $op3;
  53. is($op->{i}, 3, "reversed operator subtraction (with int)");
  54. # subtractive assignment operator
  55. $op->{i} = 6;
  56. $op2->{i} = 3;
  57. $op -= $op2;
  58. is($op->{i}, 3, "operator subtractive assignment");
  59. # multiplication operator
  60. $op->{i} = 3;
  61. $op2->{i} = 3;
  62. $op3 = $op * $op2;
  63. is($op3->{i}, 9, "operator multiplication");
  64. # division operator
  65. $op->{i} = 9;
  66. $op2->{i} = 3;
  67. $op3 = $op / $op2;
  68. is($op3->{i}, 3, "operator division");
  69. # modulus operator
  70. $op->{i} = 8;
  71. $op2->{i} = 3;
  72. $op3 = $op % $op2;
  73. is($op3->{i}, 2, "operator modulus");
  74. # greater than operator
  75. $op->{i} = 8;
  76. $op2->{i} = 3;
  77. ok($op > $op2, "operator greater than");
  78. ok_not(($op2 > $op), "operator greater than");
  79. $op->{i} = 3;
  80. ok_not(($op2 > $op), "operator greater than");
  81. ok_not(($op > $op2), "operator greater than");
  82. # greater than or equal operator
  83. $op->{i} = 8;
  84. $op2->{i} = 3;
  85. ok($op >= $op2, "operator greater than or equal");
  86. ok_not(($op2 >= $op), "operator greater than or equal");
  87. $op->{i} = 3;
  88. ok(($op2 >= $op), "operator greater than or equal");
  89. ok(($op >= $op2), "operator greater than or equal");
  90. # lesser than operator
  91. $op2->{i} = 8;
  92. $op->{i} = 3;
  93. ok($op < $op2, "operator lesser than");
  94. ok_not(($op2 < $op), "operator lesser than");
  95. $op2->{i} = 3;
  96. ok_not(($op2 < $op), "operator lesser than");
  97. ok_not(($op < $op2), "operator lesser than");
  98. # less than or equal operator
  99. $op2->{i} = 8;
  100. $op->{i} = 3;
  101. ok($op <= $op2, "operator lesser than or equal");
  102. ok_not(($op2 <= $op), "operator lesser than or equal");
  103. $op2->{i} = 3;
  104. ok(($op2 <= $op), "operator less than or equal");
  105. ok(($op <= $op2), "operator less than or equal");
  106. # post-increment operator
  107. $op->{i} = 7;
  108. $op++;
  109. is($op->{i}, 8, "operator post-increment");
  110. # pre-increment operator
  111. $op->{i} = 7;
  112. ++$op;
  113. is($op->{i}, 8, "operator pre-increment");
  114. # post-decrement operator
  115. $op->{i} = 7;
  116. $op--;
  117. is($op->{i}, 6, "operator post-decrement");
  118. # pre-decrement operator
  119. $op->{i} = 7;
  120. --$op;
  121. is($op->{i}, 6, "operator pre-decrement");
  122. # neg operator
  123. $op->{i} = 3;
  124. $op2 = -$op;
  125. is($op2->{i}, -3, "operator neg");
  126. # not operator
  127. $op->{i} = 0;
  128. is(!$op, !0, "operator not");
  129. $op->{i} = 1;
  130. is(!$op, !1, "operator not");
  131. ### # and operator
  132. ### $op->{i} = 4;
  133. ### $op2->{i} = 2;
  134. ###
  135. ### is($op & $op2, 4 & 2, "operator and");
  136. ###
  137. ### isnt(($op & $op2), (10 & 2), "operator and - false");
  138. # fail("testing failed condition");