tests/auto/xmlpatternsschema/tst_xmlpatternsschema.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2011 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 test suite 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/QtTest>
  43
  44 #include "qxsdstatemachine_p.h"
  45 #include "qxsdschematoken_p.h"
  46
  47 using namespace QPatternist;
  48
  49 class tst_XMLPatternsSchema : public QObject
  50 {
  51     Q_OBJECT
  52
  53     public slots:
  54         void init();
  55         void cleanup();
  56
  57     private slots:
  58         void stateMachineTest1();
  59         void stateMachineTest2();
  60         void stateMachineTest3();
  61         void stateMachineTest4();
  62         void stateMachineTest5();
  63         void stateMachineTest6();
  64         void stateMachineTest7();
  65         void stateMachineTest8();
  66         void stateMachineTest9();
  67         void stateMachineTest10();
  68         void stateMachineTest11();
  69         void stateMachineTest12();
  70         void stateMachineTest13();
  71         void stateMachineTest14();
  72         void stateMachineTest15();
  73         void stateMachineTest16();
  74         void stateMachineTest17();
  75         void stateMachineTest18();
  76         void stateMachineTest19();
  77
  78     private:
  79         bool runTest(const QVector<XsdSchemaToken::NodeName> &list, XsdStateMachine<XsdSchemaToken::NodeName> &machine);
  80 };
  81
  82 void tst_XMLPatternsSchema::init()
  83 {
  84 }
  85
  86 void tst_XMLPatternsSchema::cleanup()
  87 {
  88 }
  89
  90 bool tst_XMLPatternsSchema::runTest(const QVector<XsdSchemaToken::NodeName> &list, XsdStateMachine<XsdSchemaToken::NodeName> &machine)
  91 {
  92     machine.reset();
  93     for (int i = 0; i < list.count(); ++i) {
  94         if (!machine.proceed(list.at(i)))
  95             return false;
  96     }
  97     if (!machine.inEndState())
  98         return false;
  99
 100     return true;
 101 }
 102
 103 void tst_XMLPatternsSchema::stateMachineTest1()
 104 {
 105     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 106
 107     // setup state machine for (annotation?, simpleType?) : attribute
 108     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 109     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 110     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 111
 112     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 113     machine.addTransition(startState, XsdSchemaToken::SimpleType, s2);
 114     machine.addTransition(s1, XsdSchemaToken::SimpleType, s2);
 115
 116     QVERIFY(machine.inEndState() == true);
 117     QVERIFY(machine.proceed(XsdSchemaToken::Annotation) == true);
 118     QVERIFY(machine.inEndState() == true);
 119     QVERIFY(machine.proceed(XsdSchemaToken::SimpleType) == true);
 120     QVERIFY(machine.inEndState() == true);
 121     QVERIFY(machine.proceed(XsdSchemaToken::SimpleType) == false);
 122     QVERIFY(machine.proceed(XsdSchemaToken::Annotation) == false);
 123     machine.reset();
 124     QVERIFY(machine.proceed(XsdSchemaToken::SimpleType) == true);
 125     QVERIFY(machine.inEndState() == true);
 126     QVERIFY(machine.proceed(XsdSchemaToken::Annotation) == false);
 127 }
 128
 129 void tst_XMLPatternsSchema::stateMachineTest2()
 130 {
 131     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 132
 133     // setup state machine for (annotation?, ((simpleType | complexType)?, (unique | key | keyref)*)) : element
 134     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 135     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 136     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 137     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 138     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s4 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 139     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s5 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 140     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s6 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 141
 142     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 143     machine.addTransition(startState, XsdSchemaToken::SimpleType, s2);
 144     machine.addTransition(startState, XsdSchemaToken::ComplexType, s3);
 145     machine.addTransition(startState, XsdSchemaToken::Unique, s4);
 146     machine.addTransition(startState, XsdSchemaToken::Key, s5);
 147     machine.addTransition(startState, XsdSchemaToken::Keyref, s6);
 148
 149     machine.addTransition(s1, XsdSchemaToken::SimpleType, s2);
 150     machine.addTransition(s1, XsdSchemaToken::ComplexType, s3);
 151     machine.addTransition(s1, XsdSchemaToken::Unique, s4);
 152     machine.addTransition(s1, XsdSchemaToken::Key, s5);
 153     machine.addTransition(s1, XsdSchemaToken::Keyref, s6);
 154
 155     machine.addTransition(s2, XsdSchemaToken::Unique, s4);
 156     machine.addTransition(s2, XsdSchemaToken::Key, s5);
 157     machine.addTransition(s2, XsdSchemaToken::Keyref, s6);
 158
 159     machine.addTransition(s3, XsdSchemaToken::Unique, s4);
 160     machine.addTransition(s3, XsdSchemaToken::Key, s5);
 161     machine.addTransition(s3, XsdSchemaToken::Keyref, s6);
 162
 163     machine.addTransition(s4, XsdSchemaToken::Unique, s4);
 164     machine.addTransition(s4, XsdSchemaToken::Key, s5);
 165     machine.addTransition(s4, XsdSchemaToken::Keyref, s6);
 166
 167     machine.addTransition(s5, XsdSchemaToken::Unique, s4);
 168     machine.addTransition(s5, XsdSchemaToken::Key, s5);
 169     machine.addTransition(s5, XsdSchemaToken::Keyref, s6);
 170
 171     machine.addTransition(s6, XsdSchemaToken::Unique, s4);
 172     machine.addTransition(s6, XsdSchemaToken::Key, s5);
 173     machine.addTransition(s6, XsdSchemaToken::Keyref, s6);
 174
 175     QVector<XsdSchemaToken::NodeName> data1, data2, data3;
 176
 177     data1 << XsdSchemaToken::Annotation
 178           << XsdSchemaToken::SimpleType
 179           << XsdSchemaToken::Unique
 180           << XsdSchemaToken::Keyref;
 181
 182     data2 << XsdSchemaToken::Annotation
 183           << XsdSchemaToken::SimpleType
 184           << XsdSchemaToken::Annotation
 185           << XsdSchemaToken::Keyref;
 186
 187     data3 << XsdSchemaToken::Annotation
 188           << XsdSchemaToken::SimpleType
 189           << XsdSchemaToken::SimpleType;
 190
 191     QVERIFY(runTest(data1, machine) == true);
 192     QVERIFY(runTest(data2, machine) == false);
 193     QVERIFY(runTest(data3, machine) == false);
 194 }
 195
 196 void tst_XMLPatternsSchema::stateMachineTest3()
 197 {
 198     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 199
 200     // setup state machine for (annotation?, (simpleContent | complexContent | ((group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)))) : complexType
 201     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 202     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 203     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 204     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 205     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s4 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 206     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s5 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 207     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s6 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 208     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s7 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 209     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s8 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 210     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s9 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 211     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s10 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 212
 213     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 214     machine.addTransition(startState, XsdSchemaToken::SimpleContent, s2);
 215     machine.addTransition(startState, XsdSchemaToken::ComplexContent, s3);
 216     machine.addTransition(startState, XsdSchemaToken::Group, s4);
 217     machine.addTransition(startState, XsdSchemaToken::All, s5);
 218     machine.addTransition(startState, XsdSchemaToken::Choice, s6);
 219     machine.addTransition(startState, XsdSchemaToken::Sequence, s7);
 220     machine.addTransition(startState, XsdSchemaToken::Attribute, s8);
 221     machine.addTransition(startState, XsdSchemaToken::AttributeGroup, s9);
 222     machine.addTransition(startState, XsdSchemaToken::AnyAttribute, s10);
 223
 224     machine.addTransition(s1, XsdSchemaToken::SimpleContent, s2);
 225     machine.addTransition(s1, XsdSchemaToken::ComplexContent, s3);
 226     machine.addTransition(s1, XsdSchemaToken::Group, s4);
 227     machine.addTransition(s1, XsdSchemaToken::All, s5);
 228     machine.addTransition(s1, XsdSchemaToken::Choice, s6);
 229     machine.addTransition(s1, XsdSchemaToken::Sequence, s7);
 230     machine.addTransition(s1, XsdSchemaToken::Attribute, s8);
 231     machine.addTransition(s1, XsdSchemaToken::AttributeGroup, s9);
 232     machine.addTransition(s1, XsdSchemaToken::AnyAttribute, s10);
 233
 234     machine.addTransition(s4, XsdSchemaToken::Attribute, s8);
 235     machine.addTransition(s4, XsdSchemaToken::AttributeGroup, s9);
 236     machine.addTransition(s4, XsdSchemaToken::AnyAttribute, s10);
 237
 238     machine.addTransition(s5, XsdSchemaToken::Attribute, s8);
 239     machine.addTransition(s5, XsdSchemaToken::AttributeGroup, s9);
 240     machine.addTransition(s5, XsdSchemaToken::AnyAttribute, s10);
 241
 242     machine.addTransition(s6, XsdSchemaToken::Attribute, s8);
 243     machine.addTransition(s6, XsdSchemaToken::AttributeGroup, s9);
 244     machine.addTransition(s6, XsdSchemaToken::AnyAttribute, s10);
 245
 246     machine.addTransition(s7, XsdSchemaToken::Attribute, s8);
 247     machine.addTransition(s7, XsdSchemaToken::AttributeGroup, s9);
 248     machine.addTransition(s7, XsdSchemaToken::AnyAttribute, s10);
 249
 250     machine.addTransition(s8, XsdSchemaToken::Attribute, s8);
 251     machine.addTransition(s8, XsdSchemaToken::AttributeGroup, s9);
 252     machine.addTransition(s8, XsdSchemaToken::AnyAttribute, s10);
 253
 254     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4;
 255
 256     data1 << XsdSchemaToken::Annotation
 257           << XsdSchemaToken::SimpleContent;
 258
 259     data2 << XsdSchemaToken::Group
 260           << XsdSchemaToken::Attribute
 261           << XsdSchemaToken::Attribute
 262           << XsdSchemaToken::AnyAttribute;
 263
 264     data3 << XsdSchemaToken::Group
 265           << XsdSchemaToken::Choice
 266           << XsdSchemaToken::Attribute
 267           << XsdSchemaToken::AnyAttribute;
 268
 269     data4 << XsdSchemaToken::Annotation
 270           << XsdSchemaToken::Sequence
 271           << XsdSchemaToken::AnyAttribute;
 272
 273     QVERIFY(runTest(data1, machine) == true);
 274     QVERIFY(runTest(data2, machine) == true);
 275     QVERIFY(runTest(data3, machine) == false);
 276     QVERIFY(runTest(data4, machine) == true);
 277 }
 278
 279 void tst_XMLPatternsSchema::stateMachineTest4()
 280 {
 281     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 282
 283     // setup state machine for (annotation?, ((attribute | attributeGroup)*, anyAttribute?)) : named attribute group/simple content extension/
 284     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 285     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 286     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 287     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 288     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s4 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 289
 290     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 291     machine.addTransition(startState, XsdSchemaToken::Attribute, s2);
 292     machine.addTransition(startState, XsdSchemaToken::AttributeGroup, s3);
 293     machine.addTransition(startState, XsdSchemaToken::AnyAttribute, s4);
 294
 295     machine.addTransition(s1, XsdSchemaToken::Attribute, s2);
 296     machine.addTransition(s1, XsdSchemaToken::AttributeGroup, s3);
 297     machine.addTransition(s1, XsdSchemaToken::AnyAttribute, s4);
 298
 299     machine.addTransition(s2, XsdSchemaToken::Attribute, s2);
 300     machine.addTransition(s2, XsdSchemaToken::AttributeGroup, s3);
 301     machine.addTransition(s2, XsdSchemaToken::AnyAttribute, s4);
 302
 303     machine.addTransition(s3, XsdSchemaToken::Attribute, s2);
 304     machine.addTransition(s3, XsdSchemaToken::AttributeGroup, s3);
 305     machine.addTransition(s3, XsdSchemaToken::AnyAttribute, s4);
 306
 307     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4;
 308
 309     data1 << XsdSchemaToken::Annotation;
 310
 311     data2 << XsdSchemaToken::Attribute
 312           << XsdSchemaToken::Attribute
 313           << XsdSchemaToken::Attribute
 314           << XsdSchemaToken::AnyAttribute;
 315
 316     data3 << XsdSchemaToken::Group
 317           << XsdSchemaToken::Attribute
 318           << XsdSchemaToken::AnyAttribute;
 319
 320     data4 << XsdSchemaToken::Attribute
 321           << XsdSchemaToken::AnyAttribute
 322           << XsdSchemaToken::Attribute;
 323
 324     QVERIFY(runTest(data1, machine) == true);
 325     QVERIFY(runTest(data2, machine) == true);
 326     QVERIFY(runTest(data3, machine) == false);
 327     QVERIFY(runTest(data4, machine) == false);
 328 }
 329
 330 void tst_XMLPatternsSchema::stateMachineTest5()
 331 {
 332     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 333
 334     // setup state machine for (annotation?, (all | choice | sequence)?) : group
 335     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 336     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 337     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 338     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 339     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s4 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 340
 341     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 342     machine.addTransition(startState, XsdSchemaToken::All, s2);
 343     machine.addTransition(startState, XsdSchemaToken::Choice, s3);
 344     machine.addTransition(startState, XsdSchemaToken::Sequence, s4);
 345
 346     machine.addTransition(s1, XsdSchemaToken::All, s2);
 347     machine.addTransition(s1, XsdSchemaToken::Choice, s3);
 348     machine.addTransition(s1, XsdSchemaToken::Sequence, s4);
 349
 350     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6, data7, data8, data9;
 351
 352     data1 << XsdSchemaToken::Annotation;
 353     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::All;
 354     data3 << XsdSchemaToken::Annotation << XsdSchemaToken::Choice;
 355     data4 << XsdSchemaToken::Annotation << XsdSchemaToken::Sequence;
 356     data5 << XsdSchemaToken::All;
 357     data6 << XsdSchemaToken::Choice;
 358     data7 << XsdSchemaToken::Sequence;
 359     data8 << XsdSchemaToken::Sequence << XsdSchemaToken::All;
 360
 361     QVERIFY(runTest(data1, machine) == true);
 362     QVERIFY(runTest(data2, machine) == true);
 363     QVERIFY(runTest(data3, machine) == true);
 364     QVERIFY(runTest(data4, machine) == true);
 365     QVERIFY(runTest(data5, machine) == true);
 366     QVERIFY(runTest(data6, machine) == true);
 367     QVERIFY(runTest(data7, machine) == true);
 368     QVERIFY(runTest(data8, machine) == false);
 369     QVERIFY(runTest(data9, machine) == true);
 370 }
 371
 372 void tst_XMLPatternsSchema::stateMachineTest6()
 373 {
 374     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 375
 376     // setup state machine for (annotation?, element*) : all
 377     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 378     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 379     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 380
 381     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 382     machine.addTransition(startState, XsdSchemaToken::Element, s2);
 383
 384     machine.addTransition(s1, XsdSchemaToken::Element, s2);
 385
 386     machine.addTransition(s2, XsdSchemaToken::Element, s2);
 387
 388     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6, data7, data8, data9;
 389
 390     data1 << XsdSchemaToken::Annotation;
 391     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::Element;
 392     data3 << XsdSchemaToken::Element;
 393     data4 << XsdSchemaToken::Element << XsdSchemaToken::Sequence;
 394     data5 << XsdSchemaToken::Annotation << XsdSchemaToken::Element << XsdSchemaToken::Annotation;
 395     data6 << XsdSchemaToken::Annotation << XsdSchemaToken::Annotation << XsdSchemaToken::Element;
 396
 397     QVERIFY(runTest(data1, machine) == true);
 398     QVERIFY(runTest(data2, machine) == true);
 399     QVERIFY(runTest(data3, machine) == true);
 400     QVERIFY(runTest(data4, machine) == false);
 401     QVERIFY(runTest(data5, machine) == false);
 402     QVERIFY(runTest(data6, machine) == false);
 403 }
 404
 405 void tst_XMLPatternsSchema::stateMachineTest7()
 406 {
 407     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 408
 409     // setup state machine for (annotation?, (element | group | choice | sequence | any)*) : choice sequence
 410     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 411     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 412     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 413     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 414     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s4 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 415     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s5 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 416     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s6 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 417
 418     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 419     machine.addTransition(startState, XsdSchemaToken::Element, s2);
 420     machine.addTransition(startState, XsdSchemaToken::Group, s3);
 421     machine.addTransition(startState, XsdSchemaToken::Choice, s4);
 422     machine.addTransition(startState, XsdSchemaToken::Sequence, s5);
 423     machine.addTransition(startState, XsdSchemaToken::Any, s6);
 424
 425     machine.addTransition(s1, XsdSchemaToken::Element, s2);
 426     machine.addTransition(s1, XsdSchemaToken::Group, s3);
 427     machine.addTransition(s1, XsdSchemaToken::Choice, s4);
 428     machine.addTransition(s1, XsdSchemaToken::Sequence, s5);
 429     machine.addTransition(s1, XsdSchemaToken::Any, s6);
 430
 431     machine.addTransition(s2, XsdSchemaToken::Element, s2);
 432     machine.addTransition(s2, XsdSchemaToken::Group, s3);
 433     machine.addTransition(s2, XsdSchemaToken::Choice, s4);
 434     machine.addTransition(s2, XsdSchemaToken::Sequence, s5);
 435     machine.addTransition(s2, XsdSchemaToken::Any, s6);
 436
 437     machine.addTransition(s3, XsdSchemaToken::Element, s2);
 438     machine.addTransition(s3, XsdSchemaToken::Group, s3);
 439     machine.addTransition(s3, XsdSchemaToken::Choice, s4);
 440     machine.addTransition(s3, XsdSchemaToken::Sequence, s5);
 441     machine.addTransition(s3, XsdSchemaToken::Any, s6);
 442
 443     machine.addTransition(s4, XsdSchemaToken::Element, s2);
 444     machine.addTransition(s4, XsdSchemaToken::Group, s3);
 445     machine.addTransition(s4, XsdSchemaToken::Choice, s4);
 446     machine.addTransition(s4, XsdSchemaToken::Sequence, s5);
 447     machine.addTransition(s4, XsdSchemaToken::Any, s6);
 448
 449     machine.addTransition(s5, XsdSchemaToken::Element, s2);
 450     machine.addTransition(s5, XsdSchemaToken::Group, s3);
 451     machine.addTransition(s5, XsdSchemaToken::Choice, s4);
 452     machine.addTransition(s5, XsdSchemaToken::Sequence, s5);
 453     machine.addTransition(s5, XsdSchemaToken::Any, s6);
 454
 455     machine.addTransition(s6, XsdSchemaToken::Element, s2);
 456     machine.addTransition(s6, XsdSchemaToken::Group, s3);
 457     machine.addTransition(s6, XsdSchemaToken::Choice, s4);
 458     machine.addTransition(s6, XsdSchemaToken::Sequence, s5);
 459     machine.addTransition(s6, XsdSchemaToken::Any, s6);
 460
 461     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6, data7, data8, data9;
 462
 463     data1 << XsdSchemaToken::Annotation;
 464     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::Element << XsdSchemaToken::Sequence << XsdSchemaToken::Choice;
 465     data3 << XsdSchemaToken::Group;
 466     data4 << XsdSchemaToken::Element << XsdSchemaToken::Sequence << XsdSchemaToken::Annotation;
 467
 468     QVERIFY(runTest(data1, machine) == true);
 469     QVERIFY(runTest(data2, machine) == true);
 470     QVERIFY(runTest(data3, machine) == true);
 471     QVERIFY(runTest(data4, machine) == false);
 472 }
 473
 474 void tst_XMLPatternsSchema::stateMachineTest8()
 475 {
 476     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 477
 478     // setup state machine for (annotation?) : any/selector/field/notation/include/import/referred attribute group/anyAttribute/all facets
 479     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 480     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 481
 482     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 483
 484     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4;
 485
 486     data1 << XsdSchemaToken::Annotation;
 487     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::Element;
 488     data3 << XsdSchemaToken::Group;
 489
 490     QVERIFY(runTest(data1, machine) == true);
 491     QVERIFY(runTest(data2, machine) == false);
 492     QVERIFY(runTest(data3, machine) == false);
 493     QVERIFY(runTest(data4, machine) == true);
 494 }
 495
 496 void tst_XMLPatternsSchema::stateMachineTest9()
 497 {
 498     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 499
 500     // setup state machine for (annotation?, (selector, field+)) : unique/key/keyref
 501     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartState);
 502     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::InternalState);
 503     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::InternalState);
 504     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 505
 506     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 507     machine.addTransition(startState, XsdSchemaToken::Selector, s2);
 508
 509     machine.addTransition(s1, XsdSchemaToken::Selector, s2);
 510     machine.addTransition(s2, XsdSchemaToken::Field, s3);
 511     machine.addTransition(s3, XsdSchemaToken::Field, s3);
 512
 513     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5;
 514
 515     data1 << XsdSchemaToken::Annotation;
 516     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::Selector;
 517     data3 << XsdSchemaToken::Annotation << XsdSchemaToken::Selector << XsdSchemaToken::Field;
 518     data4 << XsdSchemaToken::Selector << XsdSchemaToken::Field;
 519     data5 << XsdSchemaToken::Selector << XsdSchemaToken::Field << XsdSchemaToken::Field;
 520
 521     QVERIFY(runTest(data1, machine) == false);
 522     QVERIFY(runTest(data2, machine) == false);
 523     QVERIFY(runTest(data3, machine) == true);
 524     QVERIFY(runTest(data4, machine) == true);
 525     QVERIFY(runTest(data5, machine) == true);
 526 }
 527
 528 void tst_XMLPatternsSchema::stateMachineTest10()
 529 {
 530     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 531
 532     // setup state machine for (appinfo | documentation)* : annotation
 533     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 534     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 535     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 536
 537     machine.addTransition(startState, XsdSchemaToken::Appinfo, s1);
 538     machine.addTransition(startState, XsdSchemaToken::Documentation, s2);
 539
 540     machine.addTransition(s1, XsdSchemaToken::Appinfo, s1);
 541     machine.addTransition(s1, XsdSchemaToken::Documentation, s2);
 542
 543     machine.addTransition(s2, XsdSchemaToken::Appinfo, s1);
 544     machine.addTransition(s2, XsdSchemaToken::Documentation, s2);
 545
 546     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5;
 547
 548     data1 << XsdSchemaToken::Appinfo;
 549     data2 << XsdSchemaToken::Appinfo << XsdSchemaToken::Appinfo;
 550     data3 << XsdSchemaToken::Documentation << XsdSchemaToken::Appinfo << XsdSchemaToken::Documentation;
 551     data4 << XsdSchemaToken::Selector << XsdSchemaToken::Field;
 552
 553     QVERIFY(runTest(data1, machine) == true);
 554     QVERIFY(runTest(data2, machine) == true);
 555     QVERIFY(runTest(data3, machine) == true);
 556     QVERIFY(runTest(data4, machine) == false);
 557     QVERIFY(runTest(data5, machine) == true);
 558 }
 559
 560 void tst_XMLPatternsSchema::stateMachineTest11()
 561 {
 562     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 563
 564     // setup state machine for (annotation?, (restriction | list | union)) : simpleType
 565     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartState);
 566     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::InternalState);
 567     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 568     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 569     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s4 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 570
 571     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 572     machine.addTransition(startState, XsdSchemaToken::Restriction, s2);
 573     machine.addTransition(startState, XsdSchemaToken::List, s3);
 574     machine.addTransition(startState, XsdSchemaToken::Union, s4);
 575
 576     machine.addTransition(s1, XsdSchemaToken::Restriction, s2);
 577     machine.addTransition(s1, XsdSchemaToken::List, s3);
 578     machine.addTransition(s1, XsdSchemaToken::Union, s4);
 579
 580     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6, data7, data8;
 581
 582     data1 << XsdSchemaToken::Annotation;
 583     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::Restriction;
 584     data3 << XsdSchemaToken::Annotation << XsdSchemaToken::List;
 585     data4 << XsdSchemaToken::Annotation << XsdSchemaToken::Union;
 586     data5 << XsdSchemaToken::Restriction;
 587     data6 << XsdSchemaToken::List;
 588     data7 << XsdSchemaToken::Union;
 589     data8 << XsdSchemaToken::Union << XsdSchemaToken::Union;
 590
 591     QVERIFY(runTest(data1, machine) == false);
 592     QVERIFY(runTest(data2, machine) == true);
 593     QVERIFY(runTest(data3, machine) == true);
 594     QVERIFY(runTest(data4, machine) == true);
 595     QVERIFY(runTest(data5, machine) == true);
 596     QVERIFY(runTest(data6, machine) == true);
 597     QVERIFY(runTest(data7, machine) == true);
 598     QVERIFY(runTest(data8, machine) == false);
 599 }
 600
 601 void tst_XMLPatternsSchema::stateMachineTest12()
 602 {
 603     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 604
 605     // setup state machine for (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*)) : simple type restriction
 606     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 607     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 608     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 609     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 610
 611     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 612     machine.addTransition(startState, XsdSchemaToken::SimpleType, s2);
 613     machine.addTransition(startState, XsdSchemaToken::MinExclusive, s3);
 614     machine.addTransition(startState, XsdSchemaToken::MinInclusive, s3);
 615     machine.addTransition(startState, XsdSchemaToken::MaxExclusive, s3);
 616     machine.addTransition(startState, XsdSchemaToken::MaxInclusive, s3);
 617     machine.addTransition(startState, XsdSchemaToken::TotalDigits, s3);
 618     machine.addTransition(startState, XsdSchemaToken::FractionDigits, s3);
 619     machine.addTransition(startState, XsdSchemaToken::Length, s3);
 620     machine.addTransition(startState, XsdSchemaToken::MinLength, s3);
 621     machine.addTransition(startState, XsdSchemaToken::MaxLength, s3);
 622     machine.addTransition(startState, XsdSchemaToken::Enumeration, s3);
 623     machine.addTransition(startState, XsdSchemaToken::WhiteSpace, s3);
 624     machine.addTransition(startState, XsdSchemaToken::Pattern, s3);
 625
 626     machine.addTransition(s1, XsdSchemaToken::SimpleType, s2);
 627     machine.addTransition(s1, XsdSchemaToken::MinExclusive, s3);
 628     machine.addTransition(s1, XsdSchemaToken::MinInclusive, s3);
 629     machine.addTransition(s1, XsdSchemaToken::MaxExclusive, s3);
 630     machine.addTransition(s1, XsdSchemaToken::MaxInclusive, s3);
 631     machine.addTransition(s1, XsdSchemaToken::TotalDigits, s3);
 632     machine.addTransition(s1, XsdSchemaToken::FractionDigits, s3);
 633     machine.addTransition(s1, XsdSchemaToken::Length, s3);
 634     machine.addTransition(s1, XsdSchemaToken::MinLength, s3);
 635     machine.addTransition(s1, XsdSchemaToken::MaxLength, s3);
 636     machine.addTransition(s1, XsdSchemaToken::Enumeration, s3);
 637     machine.addTransition(s1, XsdSchemaToken::WhiteSpace, s3);
 638     machine.addTransition(s1, XsdSchemaToken::Pattern, s3);
 639
 640     machine.addTransition(s2, XsdSchemaToken::MinExclusive, s3);
 641     machine.addTransition(s2, XsdSchemaToken::MinInclusive, s3);
 642     machine.addTransition(s2, XsdSchemaToken::MaxExclusive, s3);
 643     machine.addTransition(s2, XsdSchemaToken::MaxInclusive, s3);
 644     machine.addTransition(s2, XsdSchemaToken::TotalDigits, s3);
 645     machine.addTransition(s2, XsdSchemaToken::FractionDigits, s3);
 646     machine.addTransition(s2, XsdSchemaToken::Length, s3);
 647     machine.addTransition(s2, XsdSchemaToken::MinLength, s3);
 648     machine.addTransition(s2, XsdSchemaToken::MaxLength, s3);
 649     machine.addTransition(s2, XsdSchemaToken::Enumeration, s3);
 650     machine.addTransition(s2, XsdSchemaToken::WhiteSpace, s3);
 651     machine.addTransition(s2, XsdSchemaToken::Pattern, s3);
 652
 653     machine.addTransition(s3, XsdSchemaToken::MinExclusive, s3);
 654     machine.addTransition(s3, XsdSchemaToken::MinInclusive, s3);
 655     machine.addTransition(s3, XsdSchemaToken::MaxExclusive, s3);
 656     machine.addTransition(s3, XsdSchemaToken::MaxInclusive, s3);
 657     machine.addTransition(s3, XsdSchemaToken::TotalDigits, s3);
 658     machine.addTransition(s3, XsdSchemaToken::FractionDigits, s3);
 659     machine.addTransition(s3, XsdSchemaToken::Length, s3);
 660     machine.addTransition(s3, XsdSchemaToken::MinLength, s3);
 661     machine.addTransition(s3, XsdSchemaToken::MaxLength, s3);
 662     machine.addTransition(s3, XsdSchemaToken::Enumeration, s3);
 663     machine.addTransition(s3, XsdSchemaToken::WhiteSpace, s3);
 664     machine.addTransition(s3, XsdSchemaToken::Pattern, s3);
 665
 666     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5;
 667
 668     data1 << XsdSchemaToken::Annotation;
 669     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::Length << XsdSchemaToken::MaxLength;
 670     data3 << XsdSchemaToken::Annotation << XsdSchemaToken::List;
 671     data4 << XsdSchemaToken::SimpleType << XsdSchemaToken::Pattern;
 672
 673     QVERIFY(runTest(data1, machine) == true);
 674     QVERIFY(runTest(data2, machine) == true);
 675     QVERIFY(runTest(data3, machine) == false);
 676     QVERIFY(runTest(data4, machine) == true);
 677     QVERIFY(runTest(data5, machine) == true);
 678 }
 679
 680 void tst_XMLPatternsSchema::stateMachineTest13()
 681 {
 682     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 683
 684     // setup state machine for (annotation?, simpleType?) : list
 685     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 686     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 687     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 688
 689     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 690     machine.addTransition(startState, XsdSchemaToken::SimpleType, s2);
 691
 692     machine.addTransition(s1, XsdSchemaToken::SimpleType, s2);
 693
 694     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5;
 695
 696     data1 << XsdSchemaToken::Annotation;
 697     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::SimpleType;
 698     data3 << XsdSchemaToken::SimpleType;
 699     data4 << XsdSchemaToken::SimpleType << XsdSchemaToken::SimpleType;
 700
 701     QVERIFY(runTest(data1, machine) == true);
 702     QVERIFY(runTest(data2, machine) == true);
 703     QVERIFY(runTest(data3, machine) == true);
 704     QVERIFY(runTest(data4, machine) == false);
 705     QVERIFY(runTest(data5, machine) == true);
 706 }
 707
 708 void tst_XMLPatternsSchema::stateMachineTest14()
 709 {
 710     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 711
 712     // setup state machine for (annotation?, simpleType*) : union
 713     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 714     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 715     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 716
 717     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 718     machine.addTransition(startState, XsdSchemaToken::SimpleType, s2);
 719
 720     machine.addTransition(s1, XsdSchemaToken::SimpleType, s2);
 721     machine.addTransition(s2, XsdSchemaToken::SimpleType, s2);
 722
 723     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6;
 724
 725     data1 << XsdSchemaToken::Annotation;
 726     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::SimpleType;
 727     data3 << XsdSchemaToken::SimpleType;
 728     data4 << XsdSchemaToken::SimpleType << XsdSchemaToken::SimpleType;
 729     data6 << XsdSchemaToken::Annotation << XsdSchemaToken::Annotation;
 730
 731     QVERIFY(runTest(data1, machine) == true);
 732     QVERIFY(runTest(data2, machine) == true);
 733     QVERIFY(runTest(data3, machine) == true);
 734     QVERIFY(runTest(data4, machine) == true);
 735     QVERIFY(runTest(data5, machine) == true);
 736     QVERIFY(runTest(data6, machine) == false);
 737 }
 738
 739 void tst_XMLPatternsSchema::stateMachineTest15()
 740 {
 741     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 742
 743     // setup state machine for ((include | import | redefine | annotation)*, (((simpleType | complexType | group | attributeGroup) | element | attribute | notation), annotation*)*) : schema
 744     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 745     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 746     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 747     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 748
 749     machine.addTransition(startState, XsdSchemaToken::Include, s1);
 750     machine.addTransition(startState, XsdSchemaToken::Import, s1);
 751     machine.addTransition(startState, XsdSchemaToken::Redefine, s1);
 752     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 753     machine.addTransition(startState, XsdSchemaToken::SimpleType, s2);
 754     machine.addTransition(startState, XsdSchemaToken::ComplexType, s2);
 755     machine.addTransition(startState, XsdSchemaToken::Group, s2);
 756     machine.addTransition(startState, XsdSchemaToken::AttributeGroup, s2);
 757     machine.addTransition(startState, XsdSchemaToken::Element, s2);
 758     machine.addTransition(startState, XsdSchemaToken::Attribute, s2);
 759     machine.addTransition(startState, XsdSchemaToken::Notation, s2);
 760
 761     machine.addTransition(s1, XsdSchemaToken::Include, s1);
 762     machine.addTransition(s1, XsdSchemaToken::Import, s1);
 763     machine.addTransition(s1, XsdSchemaToken::Redefine, s1);
 764     machine.addTransition(s1, XsdSchemaToken::Annotation, s1);
 765     machine.addTransition(s1, XsdSchemaToken::SimpleType, s2);
 766     machine.addTransition(s1, XsdSchemaToken::ComplexType, s2);
 767     machine.addTransition(s1, XsdSchemaToken::Group, s2);
 768     machine.addTransition(s1, XsdSchemaToken::AttributeGroup, s2);
 769     machine.addTransition(s1, XsdSchemaToken::Element, s2);
 770     machine.addTransition(s1, XsdSchemaToken::Attribute, s2);
 771     machine.addTransition(s1, XsdSchemaToken::Notation, s2);
 772
 773     machine.addTransition(s2, XsdSchemaToken::SimpleType, s2);
 774     machine.addTransition(s2, XsdSchemaToken::ComplexType, s2);
 775     machine.addTransition(s2, XsdSchemaToken::Group, s2);
 776     machine.addTransition(s2, XsdSchemaToken::AttributeGroup, s2);
 777     machine.addTransition(s2, XsdSchemaToken::Element, s2);
 778     machine.addTransition(s2, XsdSchemaToken::Attribute, s2);
 779     machine.addTransition(s2, XsdSchemaToken::Notation, s2);
 780     machine.addTransition(s2, XsdSchemaToken::Annotation, s3);
 781
 782     machine.addTransition(s3, XsdSchemaToken::SimpleType, s2);
 783     machine.addTransition(s3, XsdSchemaToken::ComplexType, s2);
 784     machine.addTransition(s3, XsdSchemaToken::Group, s2);
 785     machine.addTransition(s3, XsdSchemaToken::AttributeGroup, s2);
 786     machine.addTransition(s3, XsdSchemaToken::Element, s2);
 787     machine.addTransition(s3, XsdSchemaToken::Attribute, s2);
 788     machine.addTransition(s3, XsdSchemaToken::Notation, s2);
 789     machine.addTransition(s3, XsdSchemaToken::Annotation, s3);
 790
 791     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6;
 792
 793     data1 << XsdSchemaToken::Annotation << XsdSchemaToken::Import << XsdSchemaToken::SimpleType << XsdSchemaToken::Annotation;
 794     data2 << XsdSchemaToken::SimpleType;
 795     data3 << XsdSchemaToken::Annotation << XsdSchemaToken::Import << XsdSchemaToken::Include << XsdSchemaToken::Import;
 796     data4 << XsdSchemaToken::SimpleType << XsdSchemaToken::ComplexType << XsdSchemaToken::Annotation << XsdSchemaToken::Attribute;
 797     data5 << XsdSchemaToken::SimpleType << XsdSchemaToken::Include << XsdSchemaToken::Annotation << XsdSchemaToken::Attribute;
 798
 799     QVERIFY(runTest(data1, machine) == true);
 800     QVERIFY(runTest(data2, machine) == true);
 801     QVERIFY(runTest(data3, machine) == true);
 802     QVERIFY(runTest(data4, machine) == true);
 803     QVERIFY(runTest(data5, machine) == false);
 804     QVERIFY(runTest(data6, machine) == true);
 805 }
 806
 807 void tst_XMLPatternsSchema::stateMachineTest16()
 808 {
 809     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 810
 811     // setup state machine for (annotation | (simpleType | complexType | group | attributeGroup))* : redefine
 812     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 813     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 814
 815     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 816     machine.addTransition(startState, XsdSchemaToken::SimpleType, s1);
 817     machine.addTransition(startState, XsdSchemaToken::ComplexType, s1);
 818     machine.addTransition(startState, XsdSchemaToken::Group, s1);
 819     machine.addTransition(startState, XsdSchemaToken::AttributeGroup, s1);
 820
 821     machine.addTransition(s1, XsdSchemaToken::Annotation, s1);
 822     machine.addTransition(s1, XsdSchemaToken::SimpleType, s1);
 823     machine.addTransition(s1, XsdSchemaToken::ComplexType, s1);
 824     machine.addTransition(s1, XsdSchemaToken::Group, s1);
 825     machine.addTransition(s1, XsdSchemaToken::AttributeGroup, s1);
 826
 827     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6;
 828
 829     data1 << XsdSchemaToken::Annotation;
 830     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::SimpleType;
 831     data3 << XsdSchemaToken::SimpleType;
 832     data4 << XsdSchemaToken::SimpleType << XsdSchemaToken::SimpleType;
 833     data6 << XsdSchemaToken::Annotation << XsdSchemaToken::Annotation;
 834
 835     QVERIFY(runTest(data1, machine) == true);
 836     QVERIFY(runTest(data2, machine) == true);
 837     QVERIFY(runTest(data3, machine) == true);
 838     QVERIFY(runTest(data4, machine) == true);
 839     QVERIFY(runTest(data5, machine) == true);
 840     QVERIFY(runTest(data6, machine) == true);
 841 }
 842
 843 void tst_XMLPatternsSchema::stateMachineTest17()
 844 {
 845     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 846
 847     // setup state machine for (annotation?, (restriction | extension)) : simpleContent
 848     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartState);
 849     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::InternalState);
 850     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 851
 852     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 853     machine.addTransition(startState, XsdSchemaToken::Restriction, s2);
 854     machine.addTransition(startState, XsdSchemaToken::Extension, s2);
 855
 856     machine.addTransition(s1, XsdSchemaToken::Restriction, s2);
 857     machine.addTransition(s1, XsdSchemaToken::Extension, s2);
 858
 859     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6;
 860
 861     data1 << XsdSchemaToken::Annotation;
 862     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::Extension;
 863     data3 << XsdSchemaToken::Restriction;
 864     data4 << XsdSchemaToken::Extension << XsdSchemaToken::Restriction;
 865     data5 << XsdSchemaToken::Annotation << XsdSchemaToken::Annotation;
 866
 867     QVERIFY(runTest(data1, machine) == false);
 868     QVERIFY(runTest(data2, machine) == true);
 869     QVERIFY(runTest(data3, machine) == true);
 870     QVERIFY(runTest(data4, machine) == false);
 871     QVERIFY(runTest(data5, machine) == false);
 872     QVERIFY(runTest(data6, machine) == false);
 873 }
 874
 875 void tst_XMLPatternsSchema::stateMachineTest18()
 876 {
 877     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 878
 879     // setup state machine for (annotation?, (simpleType?, (minExclusive | minInclusive | maxExclusive | maxInclusive | totalDigits | fractionDigits | length | minLength | maxLength | enumeration | whiteSpace | pattern)*)?, ((attribute | attributeGroup)*, anyAttribute?)) : simpleContent restriction
 880     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 881     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 882     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 883     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 884     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s4 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 885     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s5 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 886
 887     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 888     machine.addTransition(startState, XsdSchemaToken::SimpleType, s2);
 889     machine.addTransition(startState, XsdSchemaToken::MinExclusive, s3);
 890     machine.addTransition(startState, XsdSchemaToken::MinInclusive, s3);
 891     machine.addTransition(startState, XsdSchemaToken::MaxExclusive, s3);
 892     machine.addTransition(startState, XsdSchemaToken::MaxInclusive, s3);
 893     machine.addTransition(startState, XsdSchemaToken::TotalDigits, s3);
 894     machine.addTransition(startState, XsdSchemaToken::FractionDigits, s3);
 895     machine.addTransition(startState, XsdSchemaToken::Length, s3);
 896     machine.addTransition(startState, XsdSchemaToken::MinLength, s3);
 897     machine.addTransition(startState, XsdSchemaToken::MaxLength, s3);
 898     machine.addTransition(startState, XsdSchemaToken::Enumeration, s3);
 899     machine.addTransition(startState, XsdSchemaToken::WhiteSpace, s3);
 900     machine.addTransition(startState, XsdSchemaToken::Pattern, s3);
 901     machine.addTransition(startState, XsdSchemaToken::Attribute, s4);
 902     machine.addTransition(startState, XsdSchemaToken::AttributeGroup, s4);
 903     machine.addTransition(startState, XsdSchemaToken::AnyAttribute, s5);
 904
 905     machine.addTransition(s1, XsdSchemaToken::SimpleType, s2);
 906     machine.addTransition(s1, XsdSchemaToken::MinExclusive, s3);
 907     machine.addTransition(s1, XsdSchemaToken::MinInclusive, s3);
 908     machine.addTransition(s1, XsdSchemaToken::MaxExclusive, s3);
 909     machine.addTransition(s1, XsdSchemaToken::MaxInclusive, s3);
 910     machine.addTransition(s1, XsdSchemaToken::TotalDigits, s3);
 911     machine.addTransition(s1, XsdSchemaToken::FractionDigits, s3);
 912     machine.addTransition(s1, XsdSchemaToken::Length, s3);
 913     machine.addTransition(s1, XsdSchemaToken::MinLength, s3);
 914     machine.addTransition(s1, XsdSchemaToken::MaxLength, s3);
 915     machine.addTransition(s1, XsdSchemaToken::Enumeration, s3);
 916     machine.addTransition(s1, XsdSchemaToken::WhiteSpace, s3);
 917     machine.addTransition(s1, XsdSchemaToken::Pattern, s3);
 918     machine.addTransition(s1, XsdSchemaToken::Attribute, s4);
 919     machine.addTransition(s1, XsdSchemaToken::AttributeGroup, s4);
 920     machine.addTransition(s1, XsdSchemaToken::AnyAttribute, s5);
 921
 922     machine.addTransition(s2, XsdSchemaToken::MinExclusive, s3);
 923     machine.addTransition(s2, XsdSchemaToken::MinInclusive, s3);
 924     machine.addTransition(s2, XsdSchemaToken::MaxExclusive, s3);
 925     machine.addTransition(s2, XsdSchemaToken::MaxInclusive, s3);
 926     machine.addTransition(s2, XsdSchemaToken::TotalDigits, s3);
 927     machine.addTransition(s2, XsdSchemaToken::FractionDigits, s3);
 928     machine.addTransition(s2, XsdSchemaToken::Length, s3);
 929     machine.addTransition(s2, XsdSchemaToken::MinLength, s3);
 930     machine.addTransition(s2, XsdSchemaToken::MaxLength, s3);
 931     machine.addTransition(s2, XsdSchemaToken::Enumeration, s3);
 932     machine.addTransition(s2, XsdSchemaToken::WhiteSpace, s3);
 933     machine.addTransition(s2, XsdSchemaToken::Pattern, s3);
 934     machine.addTransition(s2, XsdSchemaToken::Attribute, s4);
 935     machine.addTransition(s2, XsdSchemaToken::AttributeGroup, s4);
 936     machine.addTransition(s2, XsdSchemaToken::AnyAttribute, s5);
 937
 938     machine.addTransition(s3, XsdSchemaToken::MinExclusive, s3);
 939     machine.addTransition(s3, XsdSchemaToken::MinInclusive, s3);
 940     machine.addTransition(s3, XsdSchemaToken::MaxExclusive, s3);
 941     machine.addTransition(s3, XsdSchemaToken::MaxInclusive, s3);
 942     machine.addTransition(s3, XsdSchemaToken::TotalDigits, s3);
 943     machine.addTransition(s3, XsdSchemaToken::FractionDigits, s3);
 944     machine.addTransition(s3, XsdSchemaToken::Length, s3);
 945     machine.addTransition(s3, XsdSchemaToken::MinLength, s3);
 946     machine.addTransition(s3, XsdSchemaToken::MaxLength, s3);
 947     machine.addTransition(s3, XsdSchemaToken::Enumeration, s3);
 948     machine.addTransition(s3, XsdSchemaToken::WhiteSpace, s3);
 949     machine.addTransition(s3, XsdSchemaToken::Pattern, s3);
 950     machine.addTransition(s3, XsdSchemaToken::Attribute, s4);
 951     machine.addTransition(s3, XsdSchemaToken::AttributeGroup, s4);
 952     machine.addTransition(s3, XsdSchemaToken::AnyAttribute, s5);
 953
 954     machine.addTransition(s4, XsdSchemaToken::Attribute, s4);
 955     machine.addTransition(s4, XsdSchemaToken::AttributeGroup, s4);
 956     machine.addTransition(s4, XsdSchemaToken::AnyAttribute, s5);
 957
 958     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6;
 959
 960     data1 << XsdSchemaToken::Annotation;
 961     data2 << XsdSchemaToken::SimpleType << XsdSchemaToken::MinExclusive << XsdSchemaToken::MaxExclusive;
 962     data3 << XsdSchemaToken::AnyAttribute << XsdSchemaToken::Attribute;
 963     data4 << XsdSchemaToken::MinExclusive << XsdSchemaToken::TotalDigits << XsdSchemaToken::Enumeration;
 964     data5 << XsdSchemaToken::Annotation << XsdSchemaToken::Annotation;
 965
 966     QVERIFY(runTest(data1, machine) == true);
 967     QVERIFY(runTest(data2, machine) == true);
 968     QVERIFY(runTest(data3, machine) == false);
 969     QVERIFY(runTest(data4, machine) == true);
 970     QVERIFY(runTest(data5, machine) == false);
 971     QVERIFY(runTest(data6, machine) == true);
 972 }
 973
 974 void tst_XMLPatternsSchema::stateMachineTest19()
 975 {
 976     XsdStateMachine<XsdSchemaToken::NodeName> machine;
 977
 978     // setup state machine for (annotation?, (group | all | choice | sequence)?, ((attribute | attributeGroup)*, anyAttribute?)) : complex content restriction/complex content extension
 979     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId startState = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::StartEndState);
 980     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s1 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 981     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s2 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 982     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s3 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 983     const XsdStateMachine<XsdSchemaToken::NodeName>::StateId s4 = machine.addState(XsdStateMachine<XsdSchemaToken::NodeName>::EndState);
 984
 985     machine.addTransition(startState, XsdSchemaToken::Annotation, s1);
 986     machine.addTransition(startState, XsdSchemaToken::Group, s2);
 987     machine.addTransition(startState, XsdSchemaToken::All, s2);
 988     machine.addTransition(startState, XsdSchemaToken::Choice, s2);
 989     machine.addTransition(startState, XsdSchemaToken::Sequence, s2);
 990     machine.addTransition(startState, XsdSchemaToken::Attribute, s3);
 991     machine.addTransition(startState, XsdSchemaToken::AttributeGroup, s3);
 992     machine.addTransition(startState, XsdSchemaToken::AnyAttribute, s4);
 993
 994     machine.addTransition(s1, XsdSchemaToken::Group, s2);
 995     machine.addTransition(s1, XsdSchemaToken::All, s2);
 996     machine.addTransition(s1, XsdSchemaToken::Choice, s2);
 997     machine.addTransition(s1, XsdSchemaToken::Sequence, s2);
 998     machine.addTransition(s1, XsdSchemaToken::Attribute, s3);
 999     machine.addTransition(s1, XsdSchemaToken::AttributeGroup, s3);
1000     machine.addTransition(s1, XsdSchemaToken::AnyAttribute, s4);
1001
1002     machine.addTransition(s2, XsdSchemaToken::Attribute, s3);
1003     machine.addTransition(s2, XsdSchemaToken::AttributeGroup, s3);
1004     machine.addTransition(s2, XsdSchemaToken::AnyAttribute, s4);
1005
1006     machine.addTransition(s3, XsdSchemaToken::Attribute, s3);
1007     machine.addTransition(s3, XsdSchemaToken::AttributeGroup, s3);
1008     machine.addTransition(s3, XsdSchemaToken::AnyAttribute, s4);
1009
1010     QVector<XsdSchemaToken::NodeName> data1, data2, data3, data4, data5, data6;
1011
1012     data1 << XsdSchemaToken::Annotation;
1013     data2 << XsdSchemaToken::Annotation << XsdSchemaToken::Group;
1014     data3 << XsdSchemaToken::Annotation << XsdSchemaToken::Group << XsdSchemaToken::Sequence;
1015     data4 << XsdSchemaToken::Attribute << XsdSchemaToken::Attribute;
1016     data5 << XsdSchemaToken::Attribute << XsdSchemaToken::Sequence;
1017     data6 << XsdSchemaToken::Annotation << XsdSchemaToken::Annotation;
1018
1019     QVERIFY(runTest(data1, machine) == true);
1020     QVERIFY(runTest(data2, machine) == true);
1021     QVERIFY(runTest(data3, machine) == false);
1022     QVERIFY(runTest(data4, machine) == true);
1023     QVERIFY(runTest(data5, machine) == false);
1024     QVERIFY(runTest(data6, machine) == false);
1025 }
1026
1027 QTEST_MAIN(tst_XMLPatternsSchema)
1028 #include "tst_xmlpatternsschema.moc"