1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtTest module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "QtTest/private/qtesttable_p.h"

    43 #include "QtTest/qtestdata.h"

    44 

    45 #include <QtCore/qmetaobject.h>

    46 

    47 #include <string.h>

    48 

    49 #include "QtTest/qtestassert.h"

    50 

    51 QT_BEGIN_NAMESPACE

    52 

    53 class QTestTablePrivate

    54 {

    55 public:

    56     struct ElementList

    57     {

    58         ElementList(): elementName(0), elementType(0), next(0) {}

    59         const char *elementName;

    60         int elementType;

    61         ElementList *next;

    62     };

    63 

    64     struct DataList

    65     {

    66         DataList(): data(0), next(0) {}

    67         QTestData *data;

    68         DataList *next;

    69     };

    70 

    71     QTestTablePrivate(): list(0), dataList(0) {}

    72     ~QTestTablePrivate();

    73 

    74     ElementList *list;

    75     DataList *dataList;

    76 

    77     void append(int elemType, const char *elemName);

    78     void append(QTestData *data);

    79     ElementList *elementAt(int index);

    80     QTestData *dataAt(int index);

    81 

    82     static QTestTable *currentTestTable;

    83     static QTestTable *gTable;

    84 };

    85 

    86 QTestTable *QTestTablePrivate::currentTestTable = 0;

    87 QTestTable *QTestTablePrivate::gTable = 0;

    88 

    89 QTestTablePrivate::ElementList *QTestTablePrivate::elementAt(int index)

    90 {

    91     ElementList *iter = list;

    92     for (int i = 0; i < index; ++i) {

    93         if (!iter)

    94             return 0;

    95         iter = iter->next;

    96     }

    97     return iter;

    98 }

    99 

   100 QTestData *QTestTablePrivate::dataAt(int index)

   101 {

   102     DataList *iter = dataList;

   103     for (int i = 0; i < index; ++i) {

   104         if (!iter)

   105             return 0;

   106         iter = iter->next;

   107     }

   108     return iter ? iter->data : 0;

   109 }

   110 

   111 QTestTablePrivate::~QTestTablePrivate()

   112 {

   113     DataList *dit = dataList;

   114     while (dit) {

   115         DataList *next = dit->next;

   116         delete dit->data;

   117         delete dit;

   118         dit = next;

   119     }

   120     ElementList *iter = list;

   121     while (iter) {

   122         ElementList *next = iter->next;

   123         delete iter;

   124         iter = next;

   125     }

   126 }

   127 

   128 void QTestTablePrivate::append(int elemType, const char *elemName)

   129 {

   130     ElementList *item = new ElementList;

   131     item->elementName = elemName;

   132     item->elementType = elemType;

   133     if (!list) {

   134         list = item;

   135         return;

   136     }

   137     ElementList *last = list;

   138     while (last->next != 0)

   139         last = last->next;

   140     last->next = item;

   141 }

   142 

   143 void QTestTablePrivate::append(QTestData *data)

   144 {

   145     DataList *item = new DataList;

   146     item->data = data;

   147     if (!dataList) {

   148         dataList = item;

   149         return;

   150     }

   151     DataList *last = dataList;

   152     while (last->next != 0)

   153         last = last->next;

   154     last->next = item;

   155 }

   156 

   157 void QTestTable::addColumn(int type, const char *name)

   158 {

   159     QTEST_ASSERT(type);

   160     QTEST_ASSERT(name);

   161 

   162     d->append(type, name);

   163 }

   164 

   165 int QTestTable::elementCount() const

   166 {

   167     QTestTablePrivate::ElementList *item = d->list;

   168     int count = 0;

   169     while (item) {

   170         ++count;

   171         item = item->next;

   172     }

   173     return count;

   174 }

   175 

   176 

   177 int QTestTable::dataCount() const

   178 {

   179     QTestTablePrivate::DataList *item = d->dataList;

   180     int count = 0;

   181     while (item) {

   182         ++count;

   183         item = item->next;

   184     }

   185     return count;

   186 }

   187 

   188 bool QTestTable::isEmpty() const

   189 {

   190     return !d->list;

   191 }

   192 

   193 QTestData *QTestTable::newData(const char *tag)

   194 {

   195     QTestData *dt = new QTestData(tag, this);

   196     d->append(dt);

   197     return dt;

   198 }

   199 

   200 QTestTable::QTestTable()

   201 {

   202     d = new QTestTablePrivate;

   203     QTestTablePrivate::currentTestTable = this;

   204 }

   205 

   206 QTestTable::~QTestTable()

   207 {

   208     QTestTablePrivate::currentTestTable = 0;

   209     delete d;

   210 }

   211 

   212 int QTestTable::elementTypeId(int index) const

   213 {

   214     QTestTablePrivate::ElementList *item = d->elementAt(index);

   215     if (!item)

   216         return -1;

   217     return item->elementType;

   218 }

   219 

   220 const char *QTestTable::dataTag(int index) const

   221 {

   222     QTestTablePrivate::ElementList *item = d->elementAt(index);

   223     if (!item)

   224         return 0;

   225     return item->elementName;

   226 }

   227 

   228 QTestData *QTestTable::testData(int index) const

   229 {

   230     return d->dataAt(index);

   231 }

   232 

   233 int QTestTable::indexOf(const char *elementName) const

   234 {

   235     QTEST_ASSERT(elementName);

   236 

   237     QTestTablePrivate::ElementList *item = d->list;

   238     int i = 0;

   239     while (item) {

   240         if (strcmp(elementName, item->elementName) == 0)

   241             return i;

   242         item = item->next;

   243         ++i;

   244     }

   245     return -1;

   246 }

   247 

   248 QTestTable *QTestTable::globalTestTable()

   249 {

   250     if (!QTestTablePrivate::gTable)

   251         QTestTablePrivate::gTable = new QTestTable();

   252     return QTestTablePrivate::gTable;

   253 }

   254 

   255 void QTestTable::clearGlobalTestTable()

   256 {

   257     delete QTestTablePrivate::gTable;

   258     QTestTablePrivate::gTable = 0;

   259 }

   260 

   261 QTestTable *QTestTable::currentTestTable()

   262 {

   263     return QTestTablePrivate::currentTestTable;

   264 }

   265 

   266 QT_END_NAMESPACE