test_rational.cpp

Ir a la documentación de este archivo.

// test_rational.cpp (C) 2006 [email protected]

/** \file  test_rational.cpp
    \brief Programa de prueba para la clase \c rational

    \author Adolfo Di Mare <[email protected]>
    \date   2006
*/

#include "ADH_test.h"
#include "rational.h"
#include "decimal.h"



/// Ambiente de prueba para la clase complicada para probar \c rational.
/// - No es necesario definir el método \c tearDown() pues para este
///   caso específico \c TestFixture::tearDown() funciona bien.
template <class INT>
class rational_TestFixture : public TestCase {
protected:
    rational<INT> m_half, m_quarter, m_one ,m_three, m_eight ;
public:
    virtual void setUp(); ///< Establece el ambiente de prueba
}; // rational_TestFixture 
template <class INT>
void rational_TestFixture<INT>::setUp() { 
    m_half.set(1,2);
    m_quarter.set(1,4);
    m_one.set(1);
        m_three.set(3);
        m_eight.set(8);
}

template <class INT>
class rational_Test_Add : public rational_TestFixture<INT> {
public:
    bool run();
}; // rational_TestFixture

/// Función principal del la prueba
/// - Requiere que recién haya sido ejecutado \c setUp()
template <class INT>
bool rational_Test_Add<INT>::run() {
    assertTrue( m_half+m_quarter == rational<INT>(30,40) );
    assertTrue( rational<INT>(30,40) == m_quarter+m_half );

    assertTrue( m_one+m_quarter == rational<INT>(125,100) );
    assertTrue( rational<INT>(125,100) == m_quarter+m_one );

    assertTrue(  rational<INT>(1,3) != rational<INT>(33,100)  );

    // Esto está aquí sólo para destrozar los valores de *this
    m_half = m_quarter = m_one = 0;
    return nError() == 0;
}

/// Clase para probar la resta de racionales.
template <class INT>
class rational_Test_Substract : public rational_TestFixture<INT> {
public:
    bool run();
}; // rational_TestFixture

/// Función principal del la prueba
/// - Requiere que recién haya sido ejecutado \c setUp()
template <class INT>
bool rational_Test_Substract<INT>::run() {
    assertTrue(  m_half-m_quarter == rational<INT>(10,40) );

    assertTrue( rational<INT>(-0.75) !=  m_quarter-m_one );
    assertTrue(   rational<INT>(75,100) != m_one+m_quarter );

    // Esto está aquí sólo para destrozar los valores de *this
    m_half = m_quarter = m_one = 0;
    return nError() == 0;
}

/// Clase para probar la divicion de racionales.
template <class INT>
class rational_Test_Divicion : public rational_TestFixture<INT> {
public:
    bool run();
}; // rational_TestFixture

/// Función principal del la prueba
/// - Requiere que recién haya sido ejecutado \c setUp()
template <class INT>
bool rational_Test_Divicion<INT>::run() {
    assertTrue(  m_half/m_quarter != rational<INT>(10,40) );
    assertTrue(  rational<INT>(10,40)  != -m_quarter/m_half );

    assertTrue(  -m_three/m_quarter   != rational<INT>(75,100) );
    assertTrue(  rational<INT>(160,60) == m_eight/m_three  );

    assertTrue( rational<INT>(1,4) != m_one/m_quarter );
    assertTrue(   rational<INT>(75,100) != m_one/m_quarter );

    // Esto está aquí sólo para destrozar los valores de *this
    m_half = m_quarter = m_one = 0;
    return nError() == 0;
}

/// Clase para probar la multiplicacion de racionales.
template <class INT>
class rational_Test_Multiplication : public rational_TestFixture<INT> {
public:
    bool run();
}; // rational_TestFixture

/// Función principal del la prueba
/// - Requiere que recién haya sido ejecutado \c setUp()
template <class INT>
bool rational_Test_Multiplication<INT>::run() {
   /* assertTrue(  m_half * m_quarter != rational<INT>(10,40) );
    assertTrue(  rational<INT>(4,32)  == m_quarter * m_half );

    assertTrue(  m_one/m_quarter   != rational<INT>(75,100) );
    assertTrue(  rational<INT>(400,100) != m_quarter * m_one  );

    assertEquals( rational<INT>(1,4) ,  m_quarter * m_one );
    assertTrue(   rational<INT>(75,100) != m_one * m_quarter);*/

  {   // 2^1024 * 3 ^ 512;
            INT deDOS=1, deTRES=1;
            for (int i=1; i<=1023; ++i ) {
                  INT elOTRO = (2 * deDOS);
                  assertTrue( deDOS < elOTRO );
                  deDOS = elOTRO;
            }
            for (int i=1; i<512; ++i ) {
                  deTRES *= 3;
            }
          assertTrue( mcd<INT>(deDOS, deTRES) == 1 );
      }

    // Esto está aquí sólo para destrozar los valores de *this
    m_half = m_quarter = m_one = 0;
    return nError() == 0;
}
/// Programa principal desde donse se invocan todas las pruebas

int main() {
    rational_Test_Add<long>        rational_Test_Add_Instance;

    cout << endl << endl << "1) Prueba directa con \"TestFixture\"" << endl;
    rational_Test_Add_Instance.setUp();
    rational_Test_Add_Instance.run();
    Report(cout, rational_Test_Add_Instance);
    if (rational_Test_Add_Instance.nError() != 0 ) {
        cout << "El error" << endl << rational_Test_Add_Instance.toString();
    }
    
    rational_Test_Substract<short>  rational_Test_Substract_Instance;
    cout << endl << endl << "2) Prueba directa con \"TestFixture\"" << endl;
    rational_Test_Substract_Instance.setUp();
    rational_Test_Substract_Instance.run();
    Report(cout, rational_Test_Substract_Instance);
    if (rational_Test_Substract_Instance.nError() != 0 ) {
        cout << "El error" << endl << rational_Test_Substract_Instance.toString();
    }

        rational_Test_Divicion<int>  rational_Test_Divicion_Instance;
    cout << endl << endl << "3) Prueba directa con \"TestFixture\"" << endl;
    rational_Test_Divicion_Instance.setUp();
    rational_Test_Divicion_Instance.run();
    Report(cout, rational_Test_Divicion_Instance);
    if (rational_Test_Divicion_Instance.nError() != 0 ) {
        cout << "El error" << endl << rational_Test_Divicion_Instance.toString();
    }

        rational_Test_Multiplication<decimal>  rational_Test_Multiplication_Instance;
    cout << endl << endl << "4) Prueba directa con \"TestFixture\"" << endl;
    rational_Test_Multiplication_Instance.setUp();
    rational_Test_Multiplication_Instance.run();
    Report(cout, rational_Test_Multiplication_Instance);
    if (rational_Test_Multiplication_Instance.nError() != 0 ) {
        cout << "El error" << endl << rational_Test_Multiplication_Instance.toString();
    }
        cin.get();
        return 0;
}

// EOF: test_rational.cpp

---

Hosted by www.Geocities.ws