← Back to branch summary

~ubuntu-branches/ubuntu/natty/kdebase-runtime/natty-proposed

« back to all changes in this revision

Viewing changes to drkonqi/tests/backtraceparsertest/backtraceparsertest.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2010-11-24 11:07:10 UTC
  • mto: (0.8.7 upstream)
  • mto: This revision was merged to the branch mainline in revision 129.
  • Revision ID: james.westby@ubuntu.com-20101124110710-6dbsyw0yh21qvn82
Tags: upstream-4.5.80
Import upstream version 4.5.80

Show diffs side-by-side

added added

removed removed

Lines of Context:
drkonqi/tests/backtraceparsertest/backtraceparsertest.cpp
23
23
#include <QSharedPointer>
24
24
 
25
25
#define DATA_DIR "backtraceparsertest_data"
26
 
#define TEST_PREFIX "test_"
27
 
#define MAP_FILE "usefulness_map"
28
 
 
29
 
void BacktraceGenerator::sendData(const QString & filename)
30
 
{
31
 
    QFile file(filename);
32
 
    file.open(QIODevice::ReadOnly | QIODevice::Text);
33
 
    QTextStream stream(&file);
34
 
 
35
 
    emit starting();
36
 
    while (!stream.atEnd()) {
37
 
        emit newLine(stream.readLine() + '\n');
38
 
    }
39
 
    emit newLine(QString());
40
 
}
 
26
#define SETTINGS_FILE "data.ini"
41
27
 
42
28
BacktraceParserTest::BacktraceParserTest(QObject *parent)
43
 
    : QObject(parent), m_generator(new BacktraceGenerator(this))
44
 
{
45
 
}
46
 
 
47
 
void BacktraceParserTest::readMap(QHash<QByteArray, BacktraceParser::Usefulness> & map)
48
 
{
49
 
    QMetaEnum metaUsefulness = BacktraceParser::staticMetaObject.enumerator(
50
 
                                    BacktraceParser::staticMetaObject.indexOfEnumerator("Usefulness"));
51
 
 
52
 
    QFile mapFile(DATA_DIR "/" MAP_FILE);
53
 
    if ( !mapFile.open(QIODevice::ReadOnly | QIODevice::Text) ) {
54
 
        qFatal("Could not open \"" DATA_DIR "/" MAP_FILE "\".");
55
 
    }
56
 
 
57
 
    while ( !mapFile.atEnd() ) {
58
 
        QByteArray line = mapFile.readLine();
59
 
        if ( line.isEmpty() ) continue;
60
 
        QList<QByteArray> tokens = line.split(':');
61
 
        Q_ASSERT(tokens.size() == 2);
62
 
        map.insert( tokens[0].trimmed(), (BacktraceParser::Usefulness) metaUsefulness.keyToValue(tokens[1].trimmed().constData()) );
63
 
    }
64
 
}
65
 
 
66
 
void BacktraceParserTest::btParserTest_data()
 
29
    : QObject(parent),
 
30
      m_settings(DATA_DIR "/" SETTINGS_FILE, QSettings::IniFormat),
 
31
      m_generator(new FakeBacktraceGenerator(this))
 
32
{
 
33
}
 
34
 
 
35
void BacktraceParserTest::fetchData(const QString & group)
67
36
{
68
37
    QTest::addColumn<QString>("filename");
69
 
    QTest::addColumn<BacktraceParser::Usefulness>("result");
70
 
 
71
 
    if ( !QFileInfo(DATA_DIR).isDir() ) {
72
 
        qFatal("Could not find the \"" DATA_DIR "\" directory in the current directory.");
73
 
    }
74
 
 
75
 
    QHash<QByteArray, BacktraceParser::Usefulness> map;
76
 
    readMap(map);
77
 
 
78
 
    QDirIterator it(DATA_DIR, QStringList() << TEST_PREFIX"*", QDir::Files|QDir::Readable);
79
 
    while (it.hasNext()) {
80
 
        it.next();
81
 
        QTest::newRow(it.fileName().toLocal8Bit().constData())
82
 
            << it.filePath()
83
 
            << map.value(it.fileName().toLocal8Bit(), BacktraceParser::InvalidUsefulness);
84
 
    }
85
 
}
86
 
 
87
 
void BacktraceParserTest::btParserTest()
 
38
    QTest::addColumn<QString>("result");
 
39
    QTest::addColumn<QString>("debugger");
 
40
 
 
41
    m_settings.beginGroup(group);
 
42
    QStringList keys = m_settings.allKeys();
 
43
    m_settings.endGroup();
 
44
 
 
45
    foreach(const QString & key, keys) {
 
46
        QTest::newRow(key.toLocal8Bit())
 
47
            << DATA_DIR"/" + key
 
48
            << m_settings.value(group + "/" + key).toString()
 
49
            << m_settings.value("debugger/" + key).toString();
 
50
    }
 
51
}
 
52
 
 
53
void BacktraceParserTest::btParserUsefulnessTest_data()
 
54
{
 
55
    fetchData("usefulness");
 
56
}
 
57
 
 
58
void BacktraceParserTest::btParserUsefulnessTest()
88
59
{
89
60
    QFETCH(QString, filename);
90
 
    QFETCH(BacktraceParser::Usefulness, result);
91
 
    QVERIFY2(result != BacktraceParser::InvalidUsefulness, "Invalid usefulness. There is an error in the " MAP_FILE " file");
92
 
 
93
 
    QMetaEnum metaUsefulness = BacktraceParser::staticMetaObject.enumerator(
94
 
                                    BacktraceParser::staticMetaObject.indexOfEnumerator("Usefulness"));
95
 
 
96
 
    QSharedPointer<BacktraceParser> parser(BacktraceParser::newParser("gdb"));
 
61
    QFETCH(QString, result);
 
62
    QFETCH(QString, debugger);
 
63
 
 
64
    //parse
 
65
    QSharedPointer<BacktraceParser> parser(BacktraceParser::newParser(debugger));
97
66
    parser->connectToGenerator(m_generator);
98
67
    m_generator->sendData(filename);
99
68
 
100
 
    QTextStream(stdout) << "\n(" << QFileInfo(filename).fileName() << "): Received: "
101
 
                        << metaUsefulness.valueToKey(parser->backtraceUsefulness())
102
 
                        << " Expected: " << metaUsefulness.valueToKey(result) << endl;
103
 
 
104
 
    QTextStream(stdout) << "First valid functions: " << parser->firstValidFunctions().join(" ") << endl;
105
 
    QTextStream(stdout) << "Simplified backtrace:\n" << parser->simplifiedBacktrace() << endl;
106
 
    QStringList l = (QStringList)parser->librariesWithMissingDebugSymbols().toList();
107
 
    QTextStream(stdout) << "Missing dbgsym libs: " << l.join(" ") << endl;
108
 
 
 
69
    //convert usefulness to string
 
70
    QMetaEnum metaUsefulness = BacktraceParser::staticMetaObject.enumerator(
 
71
                                    BacktraceParser::staticMetaObject.indexOfEnumerator("Usefulness"));
 
72
    QString btUsefulness = metaUsefulness.valueToKey(parser->backtraceUsefulness());
 
73
 
 
74
    //compare
109
75
    QEXPECT_FAIL("test_e", "Working on it", Continue);
110
 
    QCOMPARE(parser->backtraceUsefulness(), result);
 
76
    QCOMPARE(btUsefulness, result);
 
77
}
 
78
 
 
79
void BacktraceParserTest::btParserFunctionsTest_data()
 
80
{
 
81
    fetchData("firstValidFunctions");
 
82
}
 
83
 
 
84
void BacktraceParserTest::btParserFunctionsTest()
 
85
{
 
86
    QFETCH(QString, filename);
 
87
    QFETCH(QString, result);
 
88
    QFETCH(QString, debugger);
 
89
 
 
90
    //parse
 
91
    QSharedPointer<BacktraceParser> parser(BacktraceParser::newParser(debugger));
 
92
    parser->connectToGenerator(m_generator);
 
93
    m_generator->sendData(filename);
 
94
 
 
95
    //compare
 
96
    QString functions = parser->firstValidFunctions().join("|");
 
97
    QCOMPARE(functions, result);
111
98
}
112
99
 
113
100
void BacktraceParserTest::btParserBenchmark_data()
114
101
{
115
 
    btParserTest_data(); //use the same data for the benchmark
 
102
    QTest::addColumn<QString>("filename");
 
103
    QTest::addColumn<QString>("debugger");
 
104
 
 
105
    m_settings.beginGroup("debugger");
 
106
    QStringList keys = m_settings.allKeys();
 
107
    foreach(const QString & key, keys) {
 
108
        QTest::newRow(key.toLocal8Bit())
 
109
            << DATA_DIR"/" + key
 
110
            << m_settings.value(key).toString();
 
111
    }
 
112
    m_settings.endGroup();
116
113
}
117
114
 
118
115
void BacktraceParserTest::btParserBenchmark()
119
116
{
120
117
    QFETCH(QString, filename);
121
 
    QFETCH(BacktraceParser::Usefulness, result);
122
 
    QVERIFY2(result != BacktraceParser::InvalidUsefulness, "Invalid usefulness. There is an error in the " MAP_FILE " file");
 
118
    QFETCH(QString, debugger);
123
119
 
124
 
    QSharedPointer<BacktraceParser> parser(BacktraceParser::newParser("gdb"));
 
120
    QSharedPointer<BacktraceParser> parser(BacktraceParser::newParser(debugger));
125
121
    parser->connectToGenerator(m_generator);
126
122
 
127
123
    QBENCHMARK {