rat-tst.cpp
Ir a la documentación de este archivo.
00001 // rat-tst.cpp (C) 2001, 2007 adolfo@di-mare.com 00002 00003 /** \file rat-tst.cpp 00004 \brief Programa de prueba para la clase \c rational. 00005 00006 \author Adolfo Di Mare <adolfo@di-mare.com> 00007 \date 2007 00008 */ 00009 00010 // Todo esto permite compilar con BC++ v3.1 00011 #ifndef __BORLANDC__ // Definida para Borland C++ 00012 #include "BUnit.h" 00013 #else 00014 #if (__BORLANDC__ > 0x0410) // Identifica a BC++ v3.1 y anterior 00015 #include "BUnit.h" 00016 #else // Es BC++ v3.1 00017 class TestCase { 00018 public: int failureCount() const { return 0; } 00019 public: const char * toString () const { return ""; } 00020 public: const char * report () const { return ""; } 00021 }; 00022 #include <cassert> 00023 #define assertTrue( B ) assert( B ); 00024 #endif 00025 #endif 00026 00027 #define INCLUDE_IOMANIP // setw() // ADH_port.h ==> #include <iomanip> 00028 #include <cstdlib> // rand() // ==> #include <stdlib.h> 00029 00030 #include "rational.h" 00031 00032 USING_namespace(ADH); // ADH_port.h ==> using namespace ADH; 00033 USING_namespace(std); // ADH_port.h ==> using namespace std; 00034 00035 /// Método de ordenamiento de selección. 00036 /// - Deja el arregle \c A[] ordenado. 00037 /// - Trabaja en el rango \c [0..n-1]. 00038 template <class T> 00039 void selection_sort(T* A, size_t n) { 00040 00041 for (size_t i=0, m=n-1; i<m; ++i) { 00042 size_t idx = i; 00043 T min = A[idx]; 00044 for (size_t j=i+1; j<n; ++j) { 00045 /* compare each key with current min */ 00046 if (A[j] < min) { 00047 idx = j; 00048 min = A[idx]; 00049 } 00050 } 00051 T tmp = A[i]; // Intercambia(A[i], A[idx]) 00052 A[i] = A[idx]; 00053 A[idx] = tmp; 00054 } 00055 } 00056 /// Retorna "true" cuando el vector está ordenado ascendentemente. 00057 /// - Revisa desde \c A[0] hasta \c A[N-1]. 00058 template <class T> 00059 bool Ordenado (T* A, size_t n) { 00060 for (size_t i = 0; i < n-1; ++i) { 00061 if (A[i] > A[i+1]) { 00062 return false; 00063 } 00064 } 00065 return true; 00066 } // Ordenado() 00067 00068 00069 /// Clase simple para probar \c rational. 00070 /// - Esta clase no usa variables de instancia, pues su método 00071 /// \c TestCase::run() implementa el caso de prueba completo. 00072 class rational_Test : public TestCase { 00073 public: 00074 bool run(); 00075 }; // rational_Test 00076 00077 bool rational_Test::run() { 00078 rational r, // r.rational(); 00079 s(1), // s.rational(1); 00080 t = 1, // t.rational(1); 00081 u(1,2); // u.rational(1,2); 00082 00083 assertTrue( r == 0 ); 00084 assertTrue( s == 1 ); 00085 assertTrue( t == s ); 00086 assertTrue( u == rational(1,2) ); 00087 00088 rational a = t; 00089 assertTrue( a == t ); 00090 a = t; 00091 assertTrue( a == t ); 00092 00093 (a += s * 2) += 4; 00094 assertTrue( a == 7 ); 00095 assertTrue( s == 1 ); 00096 assertTrue( 1 == s ); 00097 00098 a = rational(4, -5); 00099 rational b(-10, 6); 00100 a *= b; 00101 00102 assertTrue( a == rational( 4*-10,-5*6) ); 00103 00104 a=b; 00105 assertTrue( a == b ); 00106 assertTrue( b == a ); 00107 00108 a = rational(4, -5); 00109 a += b; 00110 assertTrue( a == rational( 4*6 + -5*-10, -5*6 ) ); 00111 00112 a -= b; 00113 assertTrue( a == rational(-4, 5) ); 00114 00115 a = b; 00116 assertTrue( a == b ); 00117 00118 a -= a; 00119 assertTrue( a == 0 ); 00120 assertTrue( 0 == a ); 00121 00122 rational c(15); 00123 assertTrue( 15 == c ); 00124 00125 a /= c; 00126 assertTrue( a == 0 ); 00127 assertTrue( 0 == a ); 00128 00129 a = 1234567l; 00130 assertTrue( a == 1234567l ); 00131 00132 long d = 4; 00133 a = d; 00134 assertTrue( a == d ); 00135 assertTrue( d == a ); 00136 00137 a += (b = 5); 00138 assertTrue( a == d+5 ); 00139 assertTrue( b == 5 ); 00140 00141 a = rational (4, -5); 00142 b = rational (5, -4); 00143 assertTrue( a*b == 1 ); 00144 assertTrue( a/b == rational( -4*4 , -5*5 ) ); 00145 assertTrue( b/a == rational( -5*5 , -4*4 ) ); 00146 00147 rational tot = 0; 00148 for (int i = 0; i <= 50; ++i) { 00149 tot += rational(i, i+1); 00150 } 00151 assertTrue( tot == rational( 64263385L, 206760032L ) ); 00152 00153 assertTrue( rational( 1,4) == rational().fromString("[ 1 / - - 4 ]")); 00154 assertTrue( rational(-1,4) == rational().fromString("[-1 / - - 4 ]")); 00155 assertTrue( rational(-1,4) == rational().fromString("[ - 1 / -- 4 ]")); 00156 assertTrue( rational( 1,4) == rational().fromString("[ - 1 / - 4 ]")); 00157 00158 00159 { // selection_sort() 00160 00161 rational VEC[17]; 00162 size_t nVEC = sizeof(VEC) / sizeof(*VEC); 00163 00164 size_t i; 00165 srand( 1492 ); 00166 for (i=0; i<nVEC; ++i) { 00167 rational r(rand(), rand()); 00168 VEC[i] = r; 00169 assertTrue( check_ok( VEC[i] ) ); 00170 assertTrue( r == VEC[i] ); 00171 } 00172 00173 selection_sort(VEC, nVEC); 00174 assertTrue( Ordenado(VEC, nVEC) ); 00175 } 00176 00177 return failureCount() == 0; 00178 } 00179 00180 /// Prueba simple del funcionamiento de los números racionales. 00181 int main() { 00182 cout << "1) Prueba directa con \"TestCase\"" << endl; 00183 rational_Test tester; 00184 tester.run(); 00185 cout << tester.report(); 00186 00187 return 0; 00188 } 00189 00190 // EOF: rat-tst.cpp
