summaryrefslogtreecommitdiffstats
path: root/kbruch/testcases/ratio_test.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commitce599e4f9f94b4eb00c1b5edb85bce5431ab3df2 (patch)
treed3bb9f5d25a2dc09ca81adecf39621d871534297 /kbruch/testcases/ratio_test.cpp
downloadtdeedu-ce599e4f9f94b4eb00c1b5edb85bce5431ab3df2.tar.gz
tdeedu-ce599e4f9f94b4eb00c1b5edb85bce5431ab3df2.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdeedu@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kbruch/testcases/ratio_test.cpp')
-rw-r--r--kbruch/testcases/ratio_test.cpp367
1 files changed, 367 insertions, 0 deletions
diff --git a/kbruch/testcases/ratio_test.cpp b/kbruch/testcases/ratio_test.cpp
new file mode 100644
index 00000000..bdc4419b
--- /dev/null
+++ b/kbruch/testcases/ratio_test.cpp
@@ -0,0 +1,367 @@
+/***************************************************************************
+
+ begin : 2004-06-03
+ copyright : (C) 2004 by Sebastian Stein
+ email : seb.kde@hpfsc.de
+
+ ***************************************************************************/
+
+/***************************************************************************
+ * *
+ * This program is free software; you can redistribute it and/or modify *
+ * it under the terms of the GNU General Public License as published by *
+ * the Free Software Foundation; either version 2 of the License, or *
+ * (at your option) any later version. *
+ * *
+ ***************************************************************************/
+
+// for BOOST testing
+#include <boost/test/unit_test.hpp>
+using boost::unit_test_framework::test_suite;
+using boost::unit_test_framework::test_case;
+
+// the class to be tested
+#include "ratio.h"
+
+
+class ratio_test
+{
+ public:
+
+ // constructor
+ ratio_test()
+ {
+ }
+
+ /** test the constructor of class ratio */
+ void test_constructor()
+ {
+ // check basic initialisation
+ ratio * ratio_a = new ratio();
+ BOOST_REQUIRE(ratio_a->numerator() == 0);
+ BOOST_REQUIRE(ratio_a->denominator() == 1);
+
+ // a denominator with value 0 is never allowed
+ ratio * ratio_b = new ratio(2, 0);
+ BOOST_REQUIRE(ratio_b->numerator() == 2);
+ BOOST_REQUIRE(ratio_b->denominator() == 1); // division by zero not allowed
+
+ // a new ratio should always be reduced
+ ratio * ratio_c = new ratio(2, 4);
+ BOOST_REQUIRE(ratio_c->numerator() == 1);
+ BOOST_REQUIRE(ratio_c->denominator() == 2);
+
+ // check copy constructor
+ ratio * ratio_d = new ratio(*ratio_c);
+ BOOST_REQUIRE(ratio_d->numerator() == 1);
+ BOOST_REQUIRE(ratio_d->denominator() == 2);
+
+ // the copy constructor is not allowed to reduce the new ratio
+ ratio_d->setNumerator(4, false);
+ ratio * ratio_e = new ratio(*ratio_d);
+ BOOST_REQUIRE(ratio_e->numerator() == 4);
+ BOOST_REQUIRE(ratio_e->denominator() == 2);
+
+ delete(ratio_a);
+ delete(ratio_b);
+ delete(ratio_c);
+ delete(ratio_d);
+ delete(ratio_e);
+
+ return;
+ }
+
+ /** test set and get functions */
+ void test_setAndGet()
+ {
+ // check setNumerator() and numerator() (get)
+ ratio * ratio_a = new ratio();
+ ratio_a->setNumerator(10);
+ BOOST_REQUIRE(ratio_a->numerator() == 10);
+ BOOST_REQUIRE(ratio_a->denominator() == 1);
+
+ // check setDenominator() and denominator() (get)
+ ratio_a->setDenominator(7);
+ BOOST_REQUIRE(ratio_a->numerator() == 10);
+ BOOST_REQUIRE(ratio_a->denominator() == 7);
+
+ // now check if the ratio gets reduced
+ ratio_a->setNumerator(14);
+ BOOST_REQUIRE(ratio_a->numerator() == 2);
+ BOOST_REQUIRE(ratio_a->denominator() == 1);
+
+ // lets do the same, but with out reducing
+ ratio_a->setNumerator(14, false);
+ ratio_a->setDenominator(7, false);
+ BOOST_REQUIRE(ratio_a->numerator() == 14);
+ BOOST_REQUIRE(ratio_a->denominator() == 7);
+
+ // now the = operator
+ ratio * ratio_b = new ratio();
+ *ratio_b = *ratio_a;
+ BOOST_REQUIRE(ratio_b->numerator() == 14);
+ BOOST_REQUIRE(ratio_b->denominator() == 7);
+
+ // make sure we didn't just copied the pointers
+ BOOST_REQUIRE(ratio_a != ratio_b);
+
+ delete(ratio_a);
+ delete(ratio_b);
+
+ return;
+ }
+
+ /** test the = operator */
+ void test_operatorSet()
+ {
+ ratio ratio_a;
+ ratio_a = 8;
+ BOOST_REQUIRE(ratio_a.numerator() == 8);
+ BOOST_REQUIRE(ratio_a.denominator() == 1);
+
+ ratio ratio_b(2, 3);
+ ratio_a = ratio_b;
+ BOOST_REQUIRE(ratio_a.numerator() == 2);
+ BOOST_REQUIRE(ratio_a.denominator() == 3);
+
+ return;
+ }
+
+ /** test the + and - operator */
+ void test_operatorAddSub()
+ {
+ ratio * ratio_a = new ratio();
+ ratio_a->setNumerator(4, false);
+ ratio_a->setDenominator(2, false);
+
+ ratio * ratio_b = new ratio();
+ ratio_b->setNumerator(4, false);
+ ratio_b->setDenominator(8, false);
+
+ // check + operator
+ ratio ratio_c = *ratio_a + *ratio_b;
+ BOOST_REQUIRE(ratio_c.numerator() == 5);
+ BOOST_REQUIRE(ratio_c.denominator() == 2);
+
+ // it should be the same if we change the addends
+ ratio_c = *ratio_b + *ratio_a;
+ BOOST_REQUIRE(ratio_c.numerator() == 5);
+ BOOST_REQUIRE(ratio_c.denominator() == 2);
+
+ // check - operator
+ ratio_c = *ratio_b - *ratio_a;
+ BOOST_REQUIRE(ratio_c.numerator() == -3);
+ BOOST_REQUIRE(ratio_c.denominator() == 2);
+
+ // it should not be the same if we change the subtrahends
+ ratio_c = *ratio_a - *ratio_b;
+ BOOST_REQUIRE(ratio_c.numerator() == 3);
+ BOOST_REQUIRE(ratio_c.denominator() == 2);
+
+ // now check if we can get 0/1
+ *ratio_a = *ratio_b;
+ ratio_c = *ratio_a - *ratio_b;
+ BOOST_REQUIRE(ratio_c.numerator() == 0);
+ BOOST_REQUIRE(ratio_c.denominator() == 1);
+
+ delete(ratio_a);
+ delete(ratio_b);
+
+ return;
+ }
+
+ /** test the * and / operator */
+ void test_operatorMulDiv()
+ {
+ ratio * ratio_a = new ratio();
+ ratio_a->setNumerator(4, false);
+ ratio_a->setDenominator(2, false);
+
+ ratio * ratio_b = new ratio();
+ ratio_b->setNumerator(4, false);
+ ratio_b->setDenominator(16, false);
+
+ // check * operator
+ ratio ratio_c = *ratio_a * *ratio_b;
+ BOOST_REQUIRE(ratio_c.numerator() == 1);
+ BOOST_REQUIRE(ratio_c.denominator() == 2);
+
+ // it should be the same if we change the addends
+ ratio_c = *ratio_b * *ratio_a;
+ BOOST_REQUIRE(ratio_c.numerator() == 1);
+ BOOST_REQUIRE(ratio_c.denominator() == 2);
+
+ // check / operator
+ ratio_c = *ratio_b / *ratio_a;
+ BOOST_REQUIRE(ratio_c.numerator() == 1);
+ BOOST_REQUIRE(ratio_c.denominator() == 8);
+
+ // it should not be the same if we change the subtrahends
+ ratio_c = *ratio_a / *ratio_b;
+ BOOST_REQUIRE(ratio_c.numerator() == 8);
+ BOOST_REQUIRE(ratio_c.denominator() == 1);
+
+ // now check if we can get 0/1
+ *ratio_a = 0;
+ ratio_c = *ratio_a * *ratio_b;
+ BOOST_REQUIRE(ratio_c.numerator() == 0);
+ BOOST_REQUIRE(ratio_c.denominator() == 1);
+ ratio_c = *ratio_a / *ratio_b;
+ BOOST_REQUIRE(ratio_c.numerator() == 0);
+ BOOST_REQUIRE(ratio_c.denominator() == 1);
+
+ delete(ratio_a);
+ delete(ratio_b);
+
+ return;
+ }
+
+ /** test function reziproc() */
+ void test_reziproc()
+ {
+ ratio ratio_a(2, 3);
+ ratio_a.reziproc();
+ BOOST_REQUIRE(ratio_a.numerator() == 3);
+ BOOST_REQUIRE(ratio_a.denominator() == 2);
+
+ return;
+ }
+
+ /** test function reduce() */
+ void test_reduce()
+ {
+ ratio ratio_a;
+ ratio_a.setNumerator(51, false);
+ ratio_a.setDenominator(17, false);
+ ratio_a.reduce();
+ BOOST_REQUIRE(ratio_a.numerator() == 3);
+ BOOST_REQUIRE(ratio_a.denominator() == 1);
+
+ return;
+ }
+
+ /** test operator compare */
+ void test_operatorCompare()
+ {
+ ratio ratio_a(2, 3);
+ ratio ratio_b(2, 3);
+ ratio ratio_c(-2, -3);
+ ratio ratio_d(2, -3);
+ ratio ratio_e(-2, 3);
+
+ BOOST_REQUIRE((ratio_a == ratio_a) == true);
+ BOOST_REQUIRE((ratio_a == ratio_b) == true);
+ BOOST_REQUIRE((ratio_a == ratio_c) == true);
+ BOOST_REQUIRE((ratio_a == ratio_d) == false);
+ BOOST_REQUIRE((ratio_a == ratio_e) == false);
+
+ return;
+ }
+
+ /** test operator smaller */
+ void test_operatorSmaller()
+ {
+ ratio ratio_a(2, 3);
+ ratio ratio_b(2, 3);
+ ratio ratio_c(-2, -3);
+ ratio ratio_d(2, -3);
+ ratio ratio_e(-2, 3);
+
+ BOOST_REQUIRE((ratio_a < ratio_a) == false);
+ BOOST_REQUIRE((ratio_a < ratio_b) == false);
+ BOOST_REQUIRE((ratio_a < ratio_c) == false);
+ BOOST_REQUIRE((ratio_a < ratio_d) == false);
+ BOOST_REQUIRE((ratio_a < ratio_e) == false);
+
+ ratio_a = ratio(-2, 3);
+
+ BOOST_REQUIRE((ratio_a < ratio_a) == false);
+ BOOST_REQUIRE((ratio_a < ratio_b) == true);
+ BOOST_REQUIRE((ratio_a < ratio_c) == true);
+ BOOST_REQUIRE((ratio_a < ratio_d) == false);
+ BOOST_REQUIRE((ratio_a < ratio_e) == false);
+
+ BOOST_REQUIRE((ratio(5, 8) < ratio(2, 1)) == true);
+
+ return;
+ }
+
+ /** test operator bigger */
+ void test_operatorBigger()
+ {
+ ratio ratio_a(2, 3);
+ ratio ratio_b(2, 3);
+ ratio ratio_c(-2, -3);
+ ratio ratio_d(2, -3);
+ ratio ratio_e(-2, 3);
+ ratio ratio_f(-4, 3);
+
+ BOOST_REQUIRE((ratio_a > ratio_a) == false);
+ BOOST_REQUIRE((ratio_a > ratio_b) == false);
+ BOOST_REQUIRE((ratio_a > ratio_c) == false);
+ BOOST_REQUIRE((ratio_a > ratio_d) == true);
+ BOOST_REQUIRE((ratio_a > ratio_e) == true);
+ BOOST_REQUIRE((ratio_a > ratio_f) == true);
+
+ ratio_a = ratio(-2, 3);
+
+ BOOST_REQUIRE((ratio_a > ratio_a) == false);
+ BOOST_REQUIRE((ratio_a > ratio_b) == false);
+ BOOST_REQUIRE((ratio_a > ratio_c) == false);
+ BOOST_REQUIRE((ratio_a > ratio_d) == false);
+ BOOST_REQUIRE((ratio_a > ratio_e) == false);
+ BOOST_REQUIRE((ratio_a > ratio_f) == true);
+
+ return;
+ }
+
+ private:
+
+ // instance of primenumber
+ ratio m_ratio;
+};
+
+class ratio_test_suite : public test_suite
+{
+ public:
+
+ ratio_test_suite() : test_suite("ratio_test_suite")
+ {
+ // create an instance of the test cases class
+ boost::shared_ptr<ratio_test> instance(new ratio_test());
+
+ // create the test cases
+ test_case* constructor_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_constructor, instance );
+ test_case* setAndGet_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_setAndGet, instance );
+ test_case* operatorSet_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_operatorSet, instance );
+ test_case* operatorAddSub_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_operatorAddSub, instance );
+ test_case* operatorMulDiv_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_operatorMulDiv, instance );
+ test_case* reziproc_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_reziproc, instance );
+ test_case* reduce_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_reduce, instance );
+ test_case* operatorCompare_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_operatorCompare, instance );
+ test_case* operatorSmaller_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_operatorSmaller, instance );
+ test_case* operatorBigger_test_case = BOOST_CLASS_TEST_CASE(
+ &ratio_test::test_operatorBigger, instance );
+
+ // add the test cases to the test suite
+ add(constructor_test_case);
+ add(setAndGet_test_case);
+ add(operatorSet_test_case);
+ add(operatorAddSub_test_case);
+ add(operatorMulDiv_test_case);
+ add(reziproc_test_case);
+ add(reduce_test_case);
+ add(operatorCompare_test_case);
+ add(operatorSmaller_test_case);
+ add(operatorBigger_test_case);
+ }
+};