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_eight, m_five;
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_eight.set(1,8);
        m_five.set(1,5);
}

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)  );

        assertTrue( m_eight+m_five == rational<INT>(13,40) );
        assertTrue( rational<INT>(13,40) == m_five+m_eight );

    // Esto está aquí sólo para destrozar los valores de *this
    m_half = m_quarter = m_one = m_eight = m_five = 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>(-10,40)  == m_quarter-m_half );

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

    assertEquals( rational<INT>(-3,4) ,  m_quarter-m_one );
    assertTrue(   rational<INT>(75,100) == m_one-m_quarter );

        assertTrue( m_eight-m_five == rational<INT>(-3,40) );
        assertTrue( rational<INT>(3,40) == m_five-m_eight );

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

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,80) );
    assertTrue( rational<INT>(10,80) == m_quarter * m_half );

    assertTrue( m_one * m_quarter == rational<INT>(10,40) );
    assertTrue( rational<INT>(10,40) == m_quarter * m_one );

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

        assertTrue( m_eight*m_five == rational<INT>(1,40) );
        assertTrue( rational<INT>(1,40) == m_five*m_eight );

    // Esto está aquí sólo para destrozar los valores de *this

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

    m_half = m_quarter = m_one = m_eight = m_five = 0;

    return nError() == 0;
}


template <class INT>
class rational_Test_Division : 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_Division<INT>::run() {
    assertTrue( m_half/m_quarter == rational<INT>(4,2) );
    assertTrue( ( rational<INT>(1,2) ) == (m_quarter/m_half) );

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

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

        assertTrue( m_eight/m_five == rational<INT>(5,8) );
        assertTrue( rational<INT>(8,5) == m_five/m_eight );

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

/// Programa principal desde donse se invocan todas las pruebas

int main() {
        rational_Test_Add< decimal >        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< decimal >  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_Multiplication< decimal >        rational_Test_Multiplication_Instance;

    cout << endl << endl << "1) 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();
    }

        rational_Test_Division< decimal >        rational_Test_Division_Instance;

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

        cin.get();

        return 0;
}

// EOF: test_rational.cpp

---

Hosted by www.Geocities.ws