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

     2 **

     3 ** Copyright (C) 2010 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 autotests 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 <QColor>

    43 #include <QFile>

    44 #include <QFileInfo>

    45 #include <QVariant>

    46 #include <QtDebug>

    47 

    48 #include "XSDTSTestCase.h"

    49 

    50 #include "qxmlschema.h"

    51 #include "qxmlschemavalidator.h"

    52 

    53 using namespace QPatternistSDK;

    54 using namespace QPatternist;

    55 

    56 XSDTSTestCase::XSDTSTestCase(const Scenario scen, TreeItem *p, TestType testType)

    57                             : m_scenario(scen)

    58                             , m_parent(p)

    59                             , m_testType(testType)

    60 {

    61 }

    62 

    63 XSDTSTestCase::~XSDTSTestCase()

    64 {

    65     qDeleteAll(m_baseLines);

    66 }

    67 

    68 TestResult::List XSDTSTestCase::execute(const ExecutionStage, TestSuite*)

    69 {

    70     ErrorHandler errHandler;

    71     ErrorHandler::installQtMessageHandler(&errHandler);

    72 

    73     TestResult::List retval;

    74     TestResult::Status resultStatus = TestResult::Unknown;

    75     QString serialized;

    76 

    77     if (m_testType == SchemaTest) {

    78         executeSchemaTest(resultStatus, serialized, &errHandler);

    79     } else {

    80         executeInstanceTest(resultStatus, serialized, &errHandler);

    81     }

    82 

    83     resultStatus = TestBaseLine::scan(serialized, baseLines());

    84     Q_ASSERT(resultStatus != TestResult::Unknown);

    85 

    86     m_result = new TestResult(name(), resultStatus, 0, errHandler.messages(),

    87                               QPatternist::Item::List(), serialized);

    88     retval.append(m_result);

    89     ErrorHandler::installQtMessageHandler(0);

    90     changed(this);

    91     return retval;

    92 }

    93 

    94 void XSDTSTestCase::executeSchemaTest(TestResult::Status &resultStatus, QString &serialized, QAbstractMessageHandler *handler)

    95 {

    96     QFile file(m_schemaUri.path());

    97     if (!file.open(QIODevice::ReadOnly)) {

    98         resultStatus = TestResult::Fail;

    99         serialized = QString();

   100         return;

   101     }

   102 

   103     QXmlSchema schema;

   104     schema.setMessageHandler(handler);

   105     schema.load(&file, m_schemaUri);

   106 

   107     if (schema.isValid()) {

   108         resultStatus = TestResult::Pass;

   109         serialized = QString::fromLatin1("true");

   110     } else {

   111         resultStatus = TestResult::Pass;

   112         serialized = QString::fromLatin1("false");

   113     }

   114 }

   115 

   116 void XSDTSTestCase::executeInstanceTest(TestResult::Status &resultStatus, QString &serialized, QAbstractMessageHandler *handler)

   117 {

   118     QFile instanceFile(m_instanceUri.path());

   119     if (!instanceFile.open(QIODevice::ReadOnly)) {

   120         resultStatus = TestResult::Fail;

   121         serialized = QString();

   122         return;

   123     }

   124 

   125     QXmlSchema schema;

   126     if (m_schemaUri.isValid()) {

   127         QFile file(m_schemaUri.path());

   128         if (!file.open(QIODevice::ReadOnly)) {

   129             resultStatus = TestResult::Fail;

   130             serialized = QString();

   131             return;

   132         }

   133 

   134         schema.setMessageHandler(handler);

   135         schema.load(&file, m_schemaUri);

   136 

   137         if (!schema.isValid()) {

   138             resultStatus = TestResult::Pass;

   139             serialized = QString::fromLatin1("false");

   140             return;

   141         }

   142     }

   143 

   144     QXmlSchemaValidator validator(schema);

   145     validator.setMessageHandler(handler);

   146 

   147     qDebug("check %s", qPrintable(m_instanceUri.path()));

   148     if (validator.validate(&instanceFile, m_instanceUri)) {

   149         resultStatus = TestResult::Pass;

   150         serialized = QString::fromLatin1("true");

   151     } else {

   152         resultStatus = TestResult::Pass;

   153         serialized = QString::fromLatin1("false");

   154     }

   155 }

   156 

   157 QVariant XSDTSTestCase::data(const Qt::ItemDataRole role, int column) const

   158 {

   159     if(role == Qt::DisplayRole)

   160     {

   161         if(column == 0)

   162             return title();

   163 

   164         const TestResult *const tr = testResult();

   165         if(!tr)

   166         {

   167             if(column == 1)

   168                 return TestResult::displayName(TestResult::NotTested);

   169             else

   170                 return QString();

   171         }

   172         const TestResult::Status status = tr->status();

   173 

   174         switch(column)

   175         {

   176             case 1:

   177                 return status == TestResult::Pass ? QString(QChar::fromLatin1('1'))

   178                                                   : QString(QChar::fromLatin1('0'));

   179             case 2:

   180                 return status == TestResult::Fail ? QString(QChar::fromLatin1('1'))

   181                                                   : QString(QChar::fromLatin1('0'));

   182             default:

   183                 return QString();

   184         }

   185     }

   186 

   187     if(role != Qt::BackgroundRole)

   188         return QVariant();

   189 

   190     const TestResult *const tr = testResult();

   191 

   192     if(!tr)

   193     {

   194         if(column == 0)

   195             return Qt::yellow;

   196         else

   197             return QVariant();

   198     }

   199 

   200     const TestResult::Status status = tr->status();

   201 

   202     if(status == TestResult::NotTested || status == TestResult::Unknown)

   203         return Qt::yellow;

   204 

   205     switch(column)

   206     {

   207         case 1:

   208             return status == TestResult::Pass ? Qt::green : QVariant();

   209         case 2:

   210             return status == TestResult::Fail ? Qt::red : QVariant();

   211         default:

   212             return QVariant();

   213     }

   214 }

   215 

   216 QString XSDTSTestCase::sourceCode(bool &ok) const

   217 {

   218     QFile file((m_testType == SchemaTest ? m_schemaUri : m_instanceUri).toLocalFile());

   219 

   220     QString err;

   221 

   222     if(!file.exists())

   223         err = QString::fromLatin1("Error: %1 does not exist.").arg(file.fileName());

   224     else if(!QFileInfo(file.fileName()).isFile())

   225         err = QString::fromLatin1("Error: %1 is not a file, cannot display it.").arg(file.fileName());

   226     else if(!file.open(QIODevice::ReadOnly))

   227         err = QString::fromLatin1("Error: Could not open %1. Likely a permission error.")

   228                                   .arg(file.fileName());

   229 

   230     if(err.isNull()) /* No errors. */

   231     {

   232         ok = true;

   233         /* Scary, we assume the query is stored in UTF-8. */

   234         return QString::fromUtf8(file.readAll());

   235     }

   236     else

   237     {

   238         ok = false;

   239         return err;

   240     }

   241 }

   242 

   243 int XSDTSTestCase::columnCount() const

   244 {

   245     return 2;

   246 }

   247 

   248 void XSDTSTestCase::addBaseLine(TestBaseLine *line)

   249 {

   250     m_baseLines.append(line);

   251 }

   252 

   253 QString XSDTSTestCase::name() const

   254 {

   255     return m_name;

   256 }

   257 

   258 QString XSDTSTestCase::creator() const

   259 {

   260     return m_creator;

   261 }

   262 

   263 QString XSDTSTestCase::description() const

   264 {

   265     return m_description;

   266 }

   267 

   268 QDate XSDTSTestCase::lastModified() const

   269 {

   270     return m_lastModified;

   271 }

   272 

   273 bool XSDTSTestCase::isXPath() const

   274 {

   275     return false;

   276 }

   277 

   278 TestCase::Scenario XSDTSTestCase::scenario() const

   279 {

   280     return m_scenario;

   281 }

   282 

   283 void XSDTSTestCase::setName(const QString &n)

   284 {

   285     m_name = n;

   286 }

   287 

   288 void XSDTSTestCase::setCreator(const QString &ctor)

   289 {

   290     m_creator = ctor;

   291 }

   292 

   293 void XSDTSTestCase::setDescription(const QString &descriptionP)

   294 {

   295     m_description = descriptionP;

   296 }

   297 

   298 void XSDTSTestCase::setLastModified(const QDate &date)

   299 {

   300     m_lastModified = date;

   301 }

   302 

   303 void XSDTSTestCase::setSchemaUri(const QUrl &uri)

   304 {

   305     m_schemaUri = uri;

   306 }

   307 

   308 void XSDTSTestCase::setInstanceUri(const QUrl &uri)

   309 {

   310     m_instanceUri = uri;

   311 }

   312 

   313 TreeItem *XSDTSTestCase::parent() const

   314 {

   315     return m_parent;

   316 }

   317 

   318 QString XSDTSTestCase::title() const

   319 {

   320     return m_name;

   321 }

   322 

   323 TestBaseLine::List XSDTSTestCase::baseLines() const

   324 {

   325     Q_ASSERT_X(!m_baseLines.isEmpty(), Q_FUNC_INFO,

   326                qPrintable(QString::fromLatin1("The test %1 has no base lines, it should have at least one.").arg(name())));

   327     return m_baseLines;

   328 }

   329 

   330 QUrl XSDTSTestCase::schemaUri() const

   331 {

   332     return m_schemaUri;

   333 }

   334 

   335 QUrl XSDTSTestCase::instanceUri() const

   336 {

   337     return m_instanceUri;

   338 }

   339 

   340 void XSDTSTestCase::setContextItemSource(const QUrl &uri)

   341 {

   342     m_contextItemSource = uri;

   343 }

   344 

   345 QUrl XSDTSTestCase::contextItemSource() const

   346 {

   347     return m_contextItemSource;

   348 }

   349 

   350 void XSDTSTestCase::setParent(TreeItem *const p)

   351 {

   352     m_parent = p;

   353 }

   354 

   355 QPatternist::ExternalVariableLoader::Ptr XSDTSTestCase::externalVariableLoader() const

   356 {

   357     return QPatternist::ExternalVariableLoader::Ptr();

   358 }

   359 

   360 TestResult *XSDTSTestCase::testResult() const

   361 {

   362     return m_result;

   363 }

   364 

   365 TestItem::ResultSummary XSDTSTestCase::resultSummary() const

   366 {

   367     if(m_result)

   368         return ResultSummary(m_result->status() == TestResult::Pass ? 1 : 0,

   369                              1);

   370 

   371     return ResultSummary(0, 1);

   372 }

   373 

   374 // vim: et:ts=4:sw=4:sts=4

   375