QTestLib. A simple example. A list of the FAILS.

[8Observer8]

Hi,

I expect to see a list of the FAILS (8 FAILS). But I see only two:

Output:

********* Start testing of Test_Complex *********
Config: Using QTest library 4.8.5, Qt 4.8.5
PASS : Test_Complex::initTestCase()
FAIL! : Test_Complex::setIm() Compared doubles are not the same (fuzzy compare)

Actual (input): 25.5
Expected (complex.getIm()): 0
../TestLib_Complex/test.cpp(19) : failure location
FAIL! : Test_Complex::setRe() Compared doubles are not the same (fuzzy compare)

Actual (input): 25.5
Expected (complex.getRe()): 0
../TestLib_Complex/test.cpp(43) : failure location
PASS : Test_Complex::cleanupTestCase()
Totals: 2 passed, 2 failed, 0 skipped
********* Finished testing of Test_Complex *********
Press <RETURN> to close this window...

This is my code:

TestLib_Complex.pro

SOURCES += \
    test.cpp
 
HEADERS += \
    complex.h
 
CONFIG += qtestlib

SOURCES += \
    test.cpp

HEADERS += \
    complex.h

CONFIG += qtestlib

To copy to clipboard, switch view to plain text mode 

complex.h

#ifndef COMPLEX_H
#define COMPLEX_H
 
class Complex {
public:
    Complex(double i = 0, double r = 0)
        :m_im(i), m_re(r){}
 
    void setIm(double i) {
        //m_im = i; // for test
    }
    void setRe(double r) {
        //m_re = r; // for test
    }
    double getIm() {
        return m_im;
    }
    double getRe() {
        return m_re;
    }
 
private:
    double m_im;
    double m_re;
};
 
#endif // COMPLEX_H

#ifndef COMPLEX_H
#define COMPLEX_H

class Complex {
public:
    Complex(double i = 0, double r = 0)
        :m_im(i), m_re(r){}

    void setIm(double i) {
        //m_im = i; // for test
    }
    void setRe(double r) {
        //m_re = r; // for test
    }
    double getIm() {
        return m_im;
    }
    double getRe() {
        return m_re;
    }

private:
    double m_im;
    double m_re;
};

#endif // COMPLEX_H

To copy to clipboard, switch view to plain text mode 

test.cpp

#include <QtTest>
#include "complex.h"
#include <QDebug>
 
class Test_Complex : public QObject {
Q_OBJECT
private slots:
    void setIm();
    void setRe();
};
 
// ----------------------------------------------------------------------
void Test_Complex::setIm()
{
    Complex complex;
 
    double input = 25.5;
    complex.setIm(input);
    QCOMPARE(input, complex.getIm());
 
    input = -5.7;
    complex.setIm(input);
    qDebug() << "input = " << input;
    qDebug() << "complex.getIm() = " << complex.getIm();
    QCOMPARE(input, complex.getIm());
 
    input = 0;
    complex.setIm(input);
    QCOMPARE(input, complex.getIm());
 
    input = 5;
    complex.setIm(input);
    QCOMPARE(input, complex.getIm());
}
 
// ----------------------------------------------------------------------
void Test_Complex::setRe()
{
    Complex complex;
 
    double input = 25.5;
    complex.setRe(input);
    QCOMPARE(input, complex.getRe());
 
    input = -5.7;
    complex.setRe(input);
    QCOMPARE(input, complex.getRe());
 
    input = 0;
    complex.setRe(input);
    QCOMPARE(input, complex.getRe());
 
    input = 5;
    complex.setRe(input);
    QCOMPARE(input, complex.getRe());
}
 
QTEST_MAIN(Test_Complex)
#include "test.moc"

#include <QtTest>
#include "complex.h"
#include <QDebug>

class Test_Complex : public QObject {
Q_OBJECT
private slots:
    void setIm();
    void setRe();
};

// ----------------------------------------------------------------------
void Test_Complex::setIm()
{
    Complex complex;

    double input = 25.5;
    complex.setIm(input);
    QCOMPARE(input, complex.getIm());

    input = -5.7;
    complex.setIm(input);
    qDebug() << "input = " << input;
    qDebug() << "complex.getIm() = " << complex.getIm();
    QCOMPARE(input, complex.getIm());

    input = 0;
    complex.setIm(input);
    QCOMPARE(input, complex.getIm());

    input = 5;
    complex.setIm(input);
    QCOMPARE(input, complex.getIm());
}

// ----------------------------------------------------------------------
void Test_Complex::setRe()
{
    Complex complex;

    double input = 25.5;
    complex.setRe(input);
    QCOMPARE(input, complex.getRe());

    input = -5.7;
    complex.setRe(input);
    QCOMPARE(input, complex.getRe());

    input = 0;
    complex.setRe(input);
    QCOMPARE(input, complex.getRe());

    input = 5;
    complex.setRe(input);
    QCOMPARE(input, complex.getRe());
}

QTEST_MAIN(Test_Complex)
#include "test.moc"

To copy to clipboard, switch view to plain text mode 

Thank you!

[nix]

According to the documentation, if a QCOMPARE fails the test is aborded. So you have two test fonctions, it gives you two fails.

[anda_skoa]

The reason is that you need to be able to check assumption before continuing to test things that are based on that assumption.

Consider a test like this

QStringList result = someTestObject->someFunction();
QCOMPARE(result.count(), 2);
QCOMPARE(result[0], "some expected string");
QCOMPARE(result[1], "some other expected string");

QStringList result = someTestObject->someFunction();
QCOMPARE(result.count(), 2);
QCOMPARE(result[0], "some expected string");
QCOMPARE(result[1], "some other expected string");

To copy to clipboard, switch view to plain text mode 

If the first QCOMPARE would not abort the test, the second or third one would lead to an assert() in QList, crashing the test program.

Cheers,
_

[8Observer8]

Thank you, guys! I understand.

---

Added after 24 minutes:

Please, say me. Is this correct code for testing of my class? I implemented testing for 'get' and 'set' methods.

I took qFuzzyCompare() function from here: http://www.qtcentre.org/threads/5290...ers?highlight=

I duplicate my code in my main project and in my TestLib_Comlex project. Must I copy/past my class (Complex) to main project all time?

Sorry for my English.

This is all my testLib project:

TestLib_Comlex.pro

SOURCES += \
    test.cpp
 
HEADERS += \
    complex.h
 
CONFIG += qtestlib

SOURCES += \
    test.cpp

HEADERS += \
    complex.h

CONFIG += qtestlib

To copy to clipboard, switch view to plain text mode 

complex.h

#ifndef COMPLEX_H
#define COMPLEX_H
 
class Complex {
public:
    Complex(double i = 0, double r = 0)
        :m_im(i), m_re(r){}
 
    void setIm(double i) {
        m_im = i;
    }
    void setRe(double r) {
        m_re = r;
    }
    double getIm() {
        return m_im;
    }
    double getRe() {
        return m_re;
    }
 
private:
    double m_im;
    double m_re;
};
 
#endif // COMPLEX_H

#ifndef COMPLEX_H
#define COMPLEX_H

class Complex {
public:
    Complex(double i = 0, double r = 0)
        :m_im(i), m_re(r){}

    void setIm(double i) {
        m_im = i;
    }
    void setRe(double r) {
        m_re = r;
    }
    double getIm() {
        return m_im;
    }
    double getRe() {
        return m_re;
    }

private:
    double m_im;
    double m_re;
};

#endif // COMPLEX_H

To copy to clipboard, switch view to plain text mode 

test.cpp

#include <QtTest>
#include "complex.h"
#include <QDebug>
 
class Test_Complex : public QObject {
    Q_OBJECT
private slots:
    void setIm();
    void setRe();
 
    static inline bool qFuzzyCompare(double p1, double p2, double delta)
    {
        return (qAbs(p1 - p2) <= delta * qMin(qAbs(p1), qAbs(p2)));
    }
};
 
// ----------------------------------------------------------------------
void Test_Complex::setIm()
{
    Complex complex;
 
    double input = 25.5123;
    complex.setIm(input);
    double expeted = complex.getIm();
    double delta = 0.0001;
    QString message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
 
    input = -5.7;
    complex.setIm(input);
    expeted = complex.getIm();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
 
    input = 0;
    complex.setIm(input);
    expeted = complex.getIm();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
 
    input = 5;
    complex.setIm(input);
    expeted = complex.getIm();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
}
 
// ----------------------------------------------------------------------
void Test_Complex::setRe()
{
    Complex complex;
 
    double input = 125.5;
    complex.setRe(input);
    double expeted = complex.getRe();
    double delta = 0.0001;
    QString message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
 
    input = -15.7;
    complex.setRe(input);
    expeted = complex.getRe();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
 
    input = 10;
    complex.setRe(input);
    expeted = complex.getRe();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
 
    input = 15;
    complex.setRe(input);
    expeted = complex.getRe();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
}
 
QTEST_MAIN(Test_Complex)
#include "test.moc"

#include <QtTest>
#include "complex.h"
#include <QDebug>

class Test_Complex : public QObject {
    Q_OBJECT
private slots:
    void setIm();
    void setRe();

    static inline bool qFuzzyCompare(double p1, double p2, double delta)
    {
        return (qAbs(p1 - p2) <= delta * qMin(qAbs(p1), qAbs(p2)));
    }
};

// ----------------------------------------------------------------------
void Test_Complex::setIm()
{
    Complex complex;

    double input = 25.5123;
    complex.setIm(input);
    double expeted = complex.getIm();
    double delta = 0.0001;
    QString message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());

    input = -5.7;
    complex.setIm(input);
    expeted = complex.getIm();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());

    input = 0;
    complex.setIm(input);
    expeted = complex.getIm();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());

    input = 5;
    complex.setIm(input);
    expeted = complex.getIm();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
}

// ----------------------------------------------------------------------
void Test_Complex::setRe()
{
    Complex complex;

    double input = 125.5;
    complex.setRe(input);
    double expeted = complex.getRe();
    double delta = 0.0001;
    QString message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());

    input = -15.7;
    complex.setRe(input);
    expeted = complex.getRe();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());

    input = 10;
    complex.setRe(input);
    expeted = complex.getRe();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());

    input = 15;
    complex.setRe(input);
    expeted = complex.getRe();
    message = QString("input = %1; expeted = %2; delta = %3").arg(input).arg(expeted).arg(delta);
    QVERIFY2(qFuzzyCompare(input, expeted, delta), message.toAscii());
}

QTEST_MAIN(Test_Complex)
#include "test.moc"

To copy to clipboard, switch view to plain text mode 

[8Observer8]

Hi,

I read about an another way of testing via addColumn(), newRow() and QFETCH. I like this way, but...

I cannot understand this errors:

********* Start testing of Test_Complex *********
Config: Using QTest library 4.8.5, Qt 4.8.5
PASS : Test_Complex::initTestCase()
QDEBUG : Test_Complex::setIm() expected data of type 'double', got 'int' for ele
ment 0 of data with tag 'setIm_test3'
QFATAL : Test_Complex::setIm() ASSERT: "false" in file qtestdata.cpp, line 94
FAIL! : Test_Complex::setIm() Received a fatal error.
Unknown file(0) : failure location
Totals: 1 passed, 1 failed, 0 skipped
********* Finished testing of Test_Complex *********

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
Press <RETURN> to close this window...

TestLib_Comlex_table.pro

HEADERS += \
    complex.h
 
SOURCES += \
    test.cpp
 
CONFIG += qtestlib

HEADERS += \
    complex.h

SOURCES += \
    test.cpp

CONFIG += qtestlib

To copy to clipboard, switch view to plain text mode 

complex.h

#ifndef COMPLEX_H
#define COMPLEX_H
 
class Complex {
public:
    Complex(double i = 0, double r = 0)
        :m_im(i), m_re(r){}
 
    void setIm(double i) {
        m_im = i;
    }
    void setRe(double r) {
        m_re = r;
    }
    double getIm() {
        return m_im;
    }
    double getRe() {
        return m_re;
    }
 
    Complex operator+(Complex c) {
        Complex sum;
        sum.m_im = m_im + c.m_im;
        sum.m_re = m_re + c.m_re;
        return sum;
    }
 
private:
    double m_im;
    double m_re;
};
 
#endif // COMPLEX_H

#ifndef COMPLEX_H
#define COMPLEX_H

class Complex {
public:
    Complex(double i = 0, double r = 0)
        :m_im(i), m_re(r){}

    void setIm(double i) {
        m_im = i;
    }
    void setRe(double r) {
        m_re = r;
    }
    double getIm() {
        return m_im;
    }
    double getRe() {
        return m_re;
    }

    Complex operator+(Complex c) {
        Complex sum;
        sum.m_im = m_im + c.m_im;
        sum.m_re = m_re + c.m_re;
        return sum;
    }

private:
    double m_im;
    double m_re;
};

#endif // COMPLEX_H

To copy to clipboard, switch view to plain text mode 

test.cpp

#include <QtTest>
#include "complex.h"
 
// ======================================================================
class Test_Complex : public QObject {
Q_OBJECT
private slots:
    void setIm_data();
    void setRe_data();
 
    void setIm();
    void setRe();
};
 
// ----------------------------------------------------------------------
void Test_Complex::setIm_data()
{
    QTest::addColumn<double>("arg1");
    QTest::addColumn<double>("result");
 
    QTest::newRow("setIm_test1") << 0.0 << 0.0;
    QTest::newRow("setIm_test2") << -12.5 << -12.5;
    QTest::newRow("setIm_test3") << 2007 << 2007;
    QTest::newRow("setIm_test4") << 5.1 << 5.1;
}
 
// ----------------------------------------------------------------------
void Test_Complex::setRe_data()
{
    QTest::addColumn<double>("arg1");
    QTest::addColumn<double>("result");
 
    QTest::newRow("setRe_test1") << 0.0 << 0.0;
    QTest::newRow("setRe_test2") << -12.5 << -12.5;
    QTest::newRow("setRe_test3") << 2007 << 2007;
    QTest::newRow("setRe_test4") << 5.1 << 5.1;
}
 
// ----------------------------------------------------------------------
void Test_Complex::setIm()
{
    Complex complex;
    QFETCH(double, arg1);
    QFETCH(double, result);
 
    complex.setIm(arg1);
 
    QCOMPARE(complex.getIm(), result);
}
 
// ----------------------------------------------------------------------
void Test_Complex::setRe()
{
    Complex complex;
    QFETCH(double, arg1);
    QFETCH(double, result);
 
    complex.setRe(arg1);
 
    QCOMPARE(complex.getRe(), result);
}
 
QTEST_MAIN(Test_Complex)
#include "test.moc"

#include <QtTest>
#include "complex.h"

// ======================================================================
class Test_Complex : public QObject {
Q_OBJECT
private slots:
    void setIm_data();
    void setRe_data();

    void setIm();
    void setRe();
};

// ----------------------------------------------------------------------
void Test_Complex::setIm_data()
{
    QTest::addColumn<double>("arg1");
    QTest::addColumn<double>("result");

    QTest::newRow("setIm_test1") << 0.0 << 0.0;
    QTest::newRow("setIm_test2") << -12.5 << -12.5;
    QTest::newRow("setIm_test3") << 2007 << 2007;
    QTest::newRow("setIm_test4") << 5.1 << 5.1;
}

// ----------------------------------------------------------------------
void Test_Complex::setRe_data()
{
    QTest::addColumn<double>("arg1");
    QTest::addColumn<double>("result");

    QTest::newRow("setRe_test1") << 0.0 << 0.0;
    QTest::newRow("setRe_test2") << -12.5 << -12.5;
    QTest::newRow("setRe_test3") << 2007 << 2007;
    QTest::newRow("setRe_test4") << 5.1 << 5.1;
}

// ----------------------------------------------------------------------
void Test_Complex::setIm()
{
    Complex complex;
    QFETCH(double, arg1);
    QFETCH(double, result);

    complex.setIm(arg1);

    QCOMPARE(complex.getIm(), result);
}

// ----------------------------------------------------------------------
void Test_Complex::setRe()
{
    Complex complex;
    QFETCH(double, arg1);
    QFETCH(double, result);

    complex.setRe(arg1);

    QCOMPARE(complex.getRe(), result);
}

QTEST_MAIN(Test_Complex)
#include "test.moc"

To copy to clipboard, switch view to plain text mode 

[nix]

Use the rigth type for data in setIm_test3 to double instead of int ( 2007 become 2007.0 )

[8Observer8]

Yes, it works now! Thank you very much!