src/tests/run_tests.cpp

Go to the documentation of this file.

#include <QApplication>
#include <QtSql>
#include <time.h>
#include <iostream>
using namespace std;

/* Change these to match your database */
#define HOST   "127.0.0.1"
#define DB     "xe"
#define PORT   1521
#define USER   "testbed"
#define PASSWD "secret"

QString clean_error_msg(QString msg) {
    return msg.replace("\n", "\n\t");
}

bool test_connect(QSqlDatabase& db) {
    if (db.open() == FALSE) {
        cout << "\n\tError: opening DB failed because " 
             << clean_error_msg(db.lastError().text()).toStdString() << endl;
        return false;
    }    
    return true;
}

bool test_create_table(QSqlDatabase& db) {
    const char create_sql[] = 
        "create table occi_datatype_example_tb ( \
            col_varchar       varchar2(100), \
            col_number        number, \
            col_char          char, \
            col_date          date, \
            col_time          timestamp, \
            col_blob          blob )";
    QSqlQuery query(db);
    
    // drop the old table and we don't care if it fails..
    query.exec("drop table occi_datatype_example_tb purge");
    
    if (query.exec(create_sql) == false) {
        cout << "\n\tError: Running query failed bacause " 
             << clean_error_msg(query.lastError().text()).toStdString() << endl;        
    }
    return true;
}

bool test_prepare(QSqlDatabase& db)
{
    QSqlQuery query(db);
    
    //if any of these fail, we have a problem...
    if (    query.prepare("select * from user_tables") == FALSE ||
            query.exec()                               == FALSE ||
            query.prepare("select * from user_tables") == FALSE ||
            query.exec()                               == FALSE) 
    { 
        cout << "Error: query failed because " 
             << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }

    return true;
}

bool test_blobs(QSqlDatabase& db)
{
    const int MAX_SIZE = 23;
    QByteArray pBlob[MAX_SIZE];
    QSqlQuery query(db);

    const char insert_sql[] = 
        "insert into occi_datatype_example_tb \
        (col_number, col_blob) \
        values \
        (:1, :2)";
 
    const char select_sql[] = 
        "select col_blob from occi_datatype_example_tb \
        where col_number = :1";
        
    srand( time(NULL) );
    
    if (query.prepare(insert_sql) == FALSE) {
        cout << "Error: query failed because " 
                << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    for (int p = 8; p < MAX_SIZE; p++) {
        for (int i = 0; i < (1<<p); i++) {
            pBlob[p].append(char(rand()));
        }

        query.bindValue(":1", p);
        query.bindValue(":2", pBlob[p]);
        
        if (query.exec() == FALSE) {
            cout << "Error: query failed because " 
                 << clean_error_msg(query.lastError().text()).toStdString() << endl;
            return false;
        }
    }
    

    
    for (int p = 8; p < MAX_SIZE; p++) {

        if (query.prepare(select_sql) == FALSE) {
            cout << "Error: query failed because " 
                    << clean_error_msg(query.lastError().text()).toStdString() << endl;
            return false;
        }

        query.bindValue(":1", p);
        
        if (query.exec() == FALSE) {
            cout << "Error: query failed because " 
                 << clean_error_msg(query.lastError().text()).toStdString() << endl;
            return false;
        }
        
        query.next();
        QByteArray ret = query.value(0).toByteArray();
        
        for (int i = 0; i < ret.length(); i++) {
            if (ret[i] != pBlob[p][i]) {
                cout << "Error: test failed because values diffed on test " << p << endl; 
                return false;
            }
        }
    }
    
    return true;
}

bool test_foward_only(QSqlDatabase& db)
{
    QSqlQuery query(db);
    query.prepare("select table_name from user_tables");
    query.setForwardOnly(TRUE);
    
    if (query.exec() == FALSE) {
        cout << "Error: query failed because " 
             << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    while (query.next()) {
        QString tbl_name = query.value(0).toString();
        bool isNull = query.isNull(0);
    }
    return true;
}

bool test_high_volume(QSqlDatabase& db)
{
    QSqlQuery query(db);
    
    const int MAX_SELECTS = 800;
    
    for (int i = 0; i < MAX_SELECTS; i++) {
    
        if (query.exec("select table_name from user_tables") == FALSE) {
            cout << "Error: query failed because " 
                << clean_error_msg(query.lastError().text()).toStdString() << endl;
            return false;
        }
        
        if (query.exec("insert into occi_datatype_example_tb (col_number) values (1234)") == FALSE) {
            cout << "Error: query failed because " 
                << clean_error_msg(query.lastError().text()).toStdString() << endl;
            return false;
        }
    }        
    return true;
}

bool test_rowid(QSqlDatabase& db) 
{
    QSqlQuery query(db);
    if (query.exec("select rowid as \"rowid\" from occi_datatype_example_tb") == FALSE) {
        cout << "Error: query failed because " 
            << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    return true;
}

bool test_varchar_boundry(QSqlDatabase& db)
{
    QSqlQuery query(db);
    if (query.exec("select col_varchar from occi_datatype_example_tb") == FALSE) {
        cout << "Error: query failed because " 
            << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    int varchar_len = query.record().field(0).length();
    QString test_str;
    
    for (int i = 0; i < varchar_len; i++) 
        test_str.append('a'+ char(rand()%26));

    
    if (query.prepare("insert into occi_datatype_example_tb (col_varchar) values (:1) ") == FALSE) {
        cout << "Error: query failed because " 
            << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    query.bindValue(":1", test_str);
    
    if (query.exec() == FALSE) {
        cout << "Error: query failed because " 
            << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    if (query.prepare("select col_varchar from occi_datatype_example_tb where col_varchar = :1") == FALSE) {
        cout << "Error: query failed because " 
            << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    query.bindValue(":1", test_str);
    
    if (query.exec() == FALSE) {
        cout << "Error: query failed because " 
            << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    while (query.next()) {
        return true;
    }
    
    return false;
}

bool test_out_binds(QSqlDatabase& db)
{
    char proc_sql[] = "create or replace procedure occi_test_proc\n(test_val out number)\nas\nbegin\ntest_val := 50;\nend occi_test_proc;\n";

    char call_sql[] = "BEGIN occi_test_proc(:0); END;";
    
    QSqlQuery query(db);
    
    if (query.exec(proc_sql) == FALSE) {
        cout << "Error: query failed because " 
            << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    QVariant test_number(QVariant::Int);
    
    query.prepare(call_sql);
    query.bindValue(0, 0);
    
    if (query.exec() == FALSE) {
        cout << "Error: query failed because " 
            << clean_error_msg(query.lastError().text()).toStdString() << endl;
        return false;
    }
    
    if (query.boundValue(0).toInt() == 50) return true;
    return false;
}

//this is not working yet...but will
bool test_named_placeholders(QSqlDatabase& db)
{
    char proc_sql[] = "create or replace procedure occi_test_proc2\n(test_val out varchar)\nas\nbegin\ntest_val := 'TEST';\nend occi_test_proc2;\n";

    char call_sql[] = "BEGIN occi_test_proc2(:str); END;";
    
    QSqlQuery query(db);
    
    if (query.exec(proc_sql) == FALSE) {
        cout << "Error: query failed because " 
             << clean_error_msg(query.lastError().text()).toStdString() << "\n"
             << "Ran [" << proc_sql << "]\n";
        return false;
    }
    
    
    query.prepare(call_sql);
    query.bindValue(":str", QVariant(QVariant::String));
    
    if (query.exec() == FALSE) {
        cout << "Error: query failed because " 
             << clean_error_msg(query.lastError().text()).toStdString() << "\n"
             << "Ran [" << call_sql << "]\n";
        return false;
    }

    if (query.boundValue(":str") == "TEST") {
        return true;
    }
    return false;
}
void test_wrapper( char* msg, bool(*func)(QSqlDatabase&), QSqlDatabase& db ) 
{
    cout << "Testing " << msg << "...";
    if (func(db)) 
        cout << "passed\n";
    else 
        cout << "Test failed!\n"; 
}

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
 
    try {
        QSqlDatabase qDB = QSqlDatabase::addDatabase("QOpenOCCI");
    
        qDB.setHostName(HOST);
        qDB.setDatabaseName(DB);
        qDB.setPort(PORT);
        qDB.setUserName(USER);
        qDB.setPassword(PASSWD);
        
        /* Probably overkill ;) */
        qDB.setConnectOptions("Prefetch_Memory=5242880;Prefetch_Rows=250");

        test_wrapper("Connect", test_connect, qDB);
        test_wrapper("Create table", test_create_table, qDB);
        test_wrapper("Blob Support", test_blobs, qDB);
        test_wrapper("Rowid", test_rowid, qDB);
        test_wrapper("Varchar Bounds", test_varchar_boundry, qDB);
        test_wrapper("Out Binds", test_out_binds, qDB);
        test_wrapper("Named Placeholders", test_named_placeholders, qDB);
        test_wrapper("High Volume", test_high_volume, qDB);
        test_wrapper("Regression 1900996 'Double Connect bug'", test_connect, qDB);
        test_wrapper("Regression 1901126 'Double Prepare bug'", test_prepare, qDB);
        test_wrapper("Regression 1901414 'Forwared Only bug'", test_foward_only, qDB);
    }
    catch (exception& e) {
        cout << e.what() << endl;
    }
    return 0;
}

---