Modulo [B]asico para prueba [unit]aria de programas: Documentación

Módulo [B]ásico para prueba [unit]aria de programas.

El archivo de encabezado BUnit.h apoya la escritura de módulos de prueba de unitaria programas. El modelo que se usa para esta implementación es similar al expuesto en este artículo "The Simplest Automated Unit Test Framework That Could Possibly Work" de Chuck Allison, que se puede obtener aquí:

Para simplificar al mínimo la tarea de programar los casos de prueba, la implementación completa de BUnit está contenida en el archivo de encabezado BUnit.h, por lo que para hacer pruebas basta poner esta directiva:
- #include "BUnit.h"
Este marco de pruebas es similar a JUnit, pues se presume que en el futuro los estudiantes usarán Java como su lenguaje principal para desarrollo de programas (pues usan C++ sólo para adiestrarse profundamente en técnicas de programación).
Ver también:
http://search.yahoo.com/search?n=100&p=JUnit+Java
Como el lenguaje C++ no tiene un mecanismo similar al de "reflexión" de Java, en cada prueba fallida se registra la condición de prueba exacta, obtenida a través de una invocación de la macro BUnit_TEST() que registra el nombre del archivo __FILE__ y el renglón __LINE__ de la prueba.
Ver también:
http://search.yahoo.com/search?n=100&p=reflection+Java
En JUnit la clase TestCase es una subclase de Assert; en BUnit no existe la clase Assert pero para mantener compatibilidad con JUnit sí se provée funcionalidad similar usando macros cuyos nombres comienzan con "assert".
Ver también:
http://search.yahoo.com/search?n=100&p=JUnit+Java+Assert+method
Para simplificar este marco de pruebas no se usa la clase TestResult que sirve para acumular resultados de las pruebas. En su lugar, se puede obtener una hilera enorme std::string que contiene el registro de todas las pruebas que no tuvieron éxito invocando el método TestCase::toString() o TestCase::toXML().

Para simplificar esta plataforma de pruebas no se hace diferencia entre un caso de prueba de prueba no existoso y uno que no tiene éxito porque no se ha levantado la excepción adecuada. Esto contrasta con JUnit, que llama "error" a un caso de prueba que ha levantado la excepción equivocada. Por eso TestCase::errorCount() siempre retorna cero 0.

    // Falla vs Error en JUnit
    public void test_Error() {
        try {
            new ArrayList(10).get( 11 );
            fail("Error si no tira IndexOutOfBoundsException" ); // error
        }
        catch (IndexOutOfBoundsException success) { } // Ok
    }
    public void test_Failure() {
        assertTrue( 1 == 2 ); // falla
    }

En BUnit.h no se hace diferencia entre "fallas" y "errores".
- En JUnit un "error" se produce cuando no se levanta la excepción adecuada.
- En JUnit una "falla" se produce cuando una aserción resulta falsa.
- Ver también:
  http://osdir.com/ml/java.junit.user/2002-06/msg00114.html
- Ver también:
  http://www.cs.waikato.ac.nz/~bernhard/314/junit3.8.1/doc/faq/faq.htm#tests_9
- Ver también:
  http://search.yahoo.com/search?n=100&p=junit+difference+failure+error

In JUnit, ¿cuál es la diferencia entre fallas y errores?

Las aseveraciones son usadas para verificar si existen fallas, y por eso las fallas son previstas con invocaciones similares a assertTrue().
Los errores son problemas no previstos que resultan de excepciones no captadas por los método de prueba JUnit.
Ver también:
http://www.cs.waikato.ac.nz/~bernhard/314/junit3.8.1/doc/faq/faq.htm#tests_9

Ver también:: http://www.cs.wm.edu/~noonan/junit/doc/faq/faq.htm#tests_9

    {{  // test::Allison()
        // Stack class for letter -- very simple (<em>Last In First Out</em>).
        // - Throws \c std::logic_error on invalid operations.
        // - Example inspired in Chuck Allison' work.
        // - http://search.yahoo.com/search?n=100&p=Simplest+Unit+Test+Allison
        class Stack {
        public:
            enum { N = 5 /* Max Capacity for the stack */ };
            // Constructor for a stack that can hold up to \c "Stack::N" values.
            Stack() : m_top(0) { m_vec[m_top] = 0; }
            // Stoes a copy of "v" at the top of the stack.
            void push(const char& v) {
                if ( m_top != N ) { m_vec[m_top] = v; m_top++; }
                else { throw std::out_of_range("Stack::push()"); }
            }
            // Removes the topmost value from the stack.
            void pop() {
                if ( m_top>0 ) { m_top--; }
                else { throw std::out_of_range("Stack::pop()"); }
            }
            // Reference to topmost value in the stack.
            char& top() {
                if ( m_top>0 ) { return m_vec[m_top-1]; }
                else { throw std::out_of_range("Stack::top()"); }
            }
            // Number of values stored in the stack.
            unsigned size() const { return m_top; }
        private:
            char m_vec[N+1] ; // Vector to hold stored values.
            int  m_top;       // Next available vector entry.
        }; // Stack

        class MyTest : public TestCase {
        public:
            bool run() {
                Stack S; // the stack

                try { // empty stack
                    S.pop();
                    fail_Msg("! S.pop()");
                }
                catch ( std::out_of_range & ex ) {
                    assertTrue( 0 == strcmp( ex.what() , "Stack::pop()" ) ); // Ok: empty stack
                }
                catch (...) {
                    fail_Msg("! ( std::out_of_range & )");
                }

                try { // Pila llena
                    for (int i=0; true; ++i) {
                        S.push('0'+i);
                        assertTrue( S.top() == '0'+i );
                    }
                    fail_Msg("! S.push()");
                }
                catch ( std::out_of_range & ex ) {
                    assertTrue( 0 == strcmp( ex.what() , "Stack::push()" ) ); // Ok: full stack
                }
                catch (...) {
                    fail_Msg("! ( std::out_of_range & )");
                }

                try { // Vacea la pila
                    for (int i=Stack::N-1; true; --i) {
                        assertTrue( S.top() == '0'+i );
                        S.pop();
                    }
                    fail_Msg("! S.pop()");
                }
                catch ( std::out_of_range & ex ) {
                    assertTrue( 0 == strcmp( ex.what() , "Stack::top()" ) ); // Ok: empty stack
                }
                catch (...) {
                    fail_Msg("! ( std::out_of_range & )");
                }
                return wasSuccessful();
            }
        }; // MyTest
        MyTest thisTest;
        thisTest.run(); // 0 failures
        assertTrue( thisTest.wasSuccessful() );
    }}

Ver también:: test_BUnit::test_Allison()