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 test suite 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 

    43 #include <QtTest/QtTest>

    44 #include <QAction>

    45 #include <QUndoStack>

    46 

    47 //TESTED_CLASS=

    48 //TESTED_FILES=

    49 

    50 /******************************************************************************

    51 ** Commands

    52 */

    53 

    54 class InsertCommand : public QUndoCommand

    55 {

    56 public:

    57     InsertCommand(QString *str, int idx, const QString &text,

    58                     QUndoCommand *parent = 0);

    59 

    60     virtual void undo();

    61     virtual void redo();

    62 

    63 private:

    64     QString *m_str;

    65     int m_idx;

    66     QString m_text;

    67 };

    68 

    69 class RemoveCommand : public QUndoCommand

    70 {

    71 public:

    72     RemoveCommand(QString *str, int idx, int len, QUndoCommand *parent = 0);

    73 

    74     virtual void undo();

    75     virtual void redo();

    76 

    77 private:

    78     QString *m_str;

    79     int m_idx;

    80     QString m_text;

    81 };

    82 

    83 class AppendCommand : public QUndoCommand

    84 {

    85 public:

    86     AppendCommand(QString *str, const QString &text, bool _fail_merge = false,

    87                     QUndoCommand *parent = 0);

    88     ~AppendCommand();

    89 

    90     virtual void undo();

    91     virtual void redo();

    92     virtual int id() const;

    93     virtual bool mergeWith(const QUndoCommand *other);

    94 

    95     bool merged;

    96     bool fail_merge;

    97     static int delete_cnt;

    98 

    99 private:

   100     QString *m_str;

   101     QString m_text;

   102 };

   103 

   104 InsertCommand::InsertCommand(QString *str, int idx, const QString &text,

   105                             QUndoCommand *parent)

   106     : QUndoCommand(parent)

   107 {

   108     QVERIFY(str->length() >= idx);

   109 

   110     setText("insert");

   111 

   112     m_str = str;

   113     m_idx = idx;

   114     m_text = text;

   115 }

   116 

   117 void InsertCommand::redo()

   118 {

   119     QVERIFY(m_str->length() >= m_idx);

   120 

   121     m_str->insert(m_idx, m_text);

   122 }

   123 

   124 void InsertCommand::undo()

   125 {

   126     QCOMPARE(m_str->mid(m_idx, m_text.length()), m_text);

   127 

   128     m_str->remove(m_idx, m_text.length());

   129 }

   130 

   131 RemoveCommand::RemoveCommand(QString *str, int idx, int len, QUndoCommand *parent)

   132     : QUndoCommand(parent)

   133 {

   134     QVERIFY(str->length() >= idx + len);

   135 

   136     setText("remove");

   137 

   138     m_str = str;

   139     m_idx = idx;

   140     m_text = m_str->mid(m_idx, len);

   141 }

   142 

   143 void RemoveCommand::redo()

   144 {

   145     QCOMPARE(m_str->mid(m_idx, m_text.length()), m_text);

   146 

   147     m_str->remove(m_idx, m_text.length());

   148 }

   149 

   150 void RemoveCommand::undo()

   151 {

   152     QVERIFY(m_str->length() >= m_idx);

   153 

   154     m_str->insert(m_idx, m_text);

   155 }

   156 

   157 int AppendCommand::delete_cnt = 0;

   158 

   159 AppendCommand::AppendCommand(QString *str, const QString &text, bool _fail_merge,

   160                                 QUndoCommand *parent)

   161     : QUndoCommand(parent)

   162 {

   163     setText("append");

   164 

   165     m_str = str;

   166     m_text = text;

   167     merged = false;

   168     fail_merge = _fail_merge;

   169 }

   170 

   171 AppendCommand::~AppendCommand()

   172 {

   173     ++delete_cnt;

   174 }

   175 

   176 void AppendCommand::redo()

   177 {

   178     m_str->append(m_text);

   179 }

   180 

   181 void AppendCommand::undo()

   182 {

   183     QCOMPARE(m_str->mid(m_str->length() - m_text.length()), m_text);

   184 

   185     m_str->truncate(m_str->length() - m_text.length());

   186 }

   187 

   188 int AppendCommand::id() const

   189 {

   190     return 1;

   191 }

   192 

   193 bool AppendCommand::mergeWith(const QUndoCommand *other)

   194 {

   195     if (other->id() != id())

   196         return false;

   197     if (fail_merge)

   198         return false;

   199     m_text += static_cast<const AppendCommand*>(other)->m_text;

   200     merged = true;

   201     return true;

   202 }

   203 

   204 /******************************************************************************

   205 ** tst_QUndoStack

   206 */

   207 

   208 class tst_QUndoStack : public QObject

   209 {

   210     Q_OBJECT

   211 public:

   212     tst_QUndoStack();

   213 

   214 private slots:

   215     void undoRedo();

   216     void setIndex();

   217     void setClean();

   218     void clear();

   219     void childCommand();

   220     void macroBeginEnd();

   221     void compression();

   222     void undoLimit();

   223 };

   224 

   225 tst_QUndoStack::tst_QUndoStack()

   226 {

   227 }

   228 

   229 static QString glue(const QString &s1, const QString &s2)

   230 {

   231     QString result;

   232 

   233     result.append(s1);

   234     if (!s1.isEmpty() && !s2.isEmpty())

   235         result.append(' ');

   236     result.append(s2);

   237 

   238     return result;

   239 }

   240 

   241 static void checkState(QSignalSpy &redoTextChangedSpy,

   242                        QSignalSpy &canRedoChangedSpy,

   243                        QSignalSpy &undoTextChangedSpy,

   244                        QAction *const redoAction,

   245                        QAction *const undoAction,

   246                        QSignalSpy &canUndoChangedSpy,

   247                        QSignalSpy &cleanChangedSpy,

   248                        QSignalSpy &indexChangedSpy,

   249                        QUndoStack &stack,

   250                        const bool _clean,

   251                        const int _count,

   252                        const int _index,

   253                        const bool _canUndo,

   254                        const QString &_undoText,

   255                        const bool _canRedo,

   256                        const QString &_redoText,

   257                        const bool _cleanChanged,

   258                        const bool _indexChanged,

   259                        const bool _undoChanged,

   260                        const bool _redoChanged)

   261 {

   262     QCOMPARE(stack.count(), _count); 

   263     QCOMPARE(stack.isClean(), _clean); 

   264     QCOMPARE(stack.index(), _index); 

   265     QCOMPARE(stack.canUndo(), _canUndo); 

   266     QCOMPARE(stack.undoText(), QString(_undoText)); 

   267     QCOMPARE(stack.canRedo(), _canRedo); 

   268     QCOMPARE(stack.redoText(), QString(_redoText)); 

   269     if (_indexChanged) { 

   270         QCOMPARE(indexChangedSpy.count(), 1); 

   271         QCOMPARE(indexChangedSpy.at(0).at(0).toInt(), _index); 

   272         indexChangedSpy.clear(); 

   273     } else { 

   274         QCOMPARE(indexChangedSpy.count(), 0); 

   275     } 

   276     if (_cleanChanged) { 

   277         QCOMPARE(cleanChangedSpy.count(), 1); 

   278         QCOMPARE(cleanChangedSpy.at(0).at(0).toBool(), _clean); 

   279         cleanChangedSpy.clear(); 

   280     } else { 

   281         QCOMPARE(cleanChangedSpy.count(), 0); 

   282     } 

   283     if (_undoChanged) { 

   284         QCOMPARE(canUndoChangedSpy.count(), 1); 

   285         QCOMPARE(canUndoChangedSpy.at(0).at(0).toBool(), _canUndo); 

   286         QCOMPARE(undoAction->isEnabled(), _canUndo); 

   287         QCOMPARE(undoTextChangedSpy.count(), 1); 

   288         QCOMPARE(undoTextChangedSpy.at(0).at(0).toString(), QString(_undoText)); 

   289         QCOMPARE(undoAction->text(), glue("foo", _undoText)); 

   290         canUndoChangedSpy.clear(); 

   291         undoTextChangedSpy.clear(); 

   292     } else { 

   293         QCOMPARE(canUndoChangedSpy.count(), 0); 

   294         QCOMPARE(undoTextChangedSpy.count(), 0); 

   295     } 

   296     if (_redoChanged) { 

   297         QCOMPARE(canRedoChangedSpy.count(), 1); 

   298         QCOMPARE(canRedoChangedSpy.at(0).at(0).toBool(), _canRedo); 

   299         QCOMPARE(redoAction->isEnabled(), _canRedo); 

   300         QCOMPARE(redoTextChangedSpy.count(), 1); 

   301         QCOMPARE(redoTextChangedSpy.at(0).at(0).toString(), QString(_redoText)); 

   302         QCOMPARE(redoAction->text(), glue("bar", _redoText)); 

   303         canRedoChangedSpy.clear(); 

   304         redoTextChangedSpy.clear(); 

   305     } else { 

   306         QCOMPARE(canRedoChangedSpy.count(), 0); 

   307         QCOMPARE(redoTextChangedSpy.count(), 0); 

   308     }

   309 }

   310 

   311 void tst_QUndoStack::undoRedo()

   312 {

   313     QUndoStack stack;

   314     QAction *undoAction = stack.createUndoAction(0, QString("foo"));

   315     QAction *redoAction = stack.createRedoAction(0, QString("bar"));

   316     QSignalSpy indexChangedSpy(&stack, SIGNAL(indexChanged(int)));

   317     QSignalSpy cleanChangedSpy(&stack, SIGNAL(cleanChanged(bool)));

   318     QSignalSpy canUndoChangedSpy(&stack, SIGNAL(canUndoChanged(bool)));

   319     QSignalSpy undoTextChangedSpy(&stack, SIGNAL(undoTextChanged(QString)));

   320     QSignalSpy canRedoChangedSpy(&stack, SIGNAL(canRedoChanged(bool)));

   321     QSignalSpy redoTextChangedSpy(&stack, SIGNAL(redoTextChanged(QString)));

   322     QString str;

   323 

   324     // push, undo, redo

   325 

   326     checkState(redoTextChangedSpy,

   327                 canRedoChangedSpy,

   328                 undoTextChangedSpy,

   329                 redoAction,

   330                 undoAction,

   331                 canUndoChangedSpy,

   332                 cleanChangedSpy,

   333                 indexChangedSpy,

   334                 stack,

   335                 true,       // clean

   336                 0,          // count

   337                 0,          // index

   338                 false,      // canUndo

   339                 "",         // undoText

   340                 false,      // canRedo

   341                 "",         // redoText

   342                 false,      // cleanChanged

   343                 false,      // indexChanged

   344                 false,      // undoChanged

   345                 false);     // redoChanged

   346 

   347     stack.undo(); // nothing to undo

   348     QCOMPARE(str, QString());

   349     checkState(redoTextChangedSpy,

   350                 canRedoChangedSpy,

   351                 undoTextChangedSpy,

   352                 redoAction,

   353                 undoAction,

   354                 canUndoChangedSpy,

   355                 cleanChangedSpy,

   356                 indexChangedSpy,

   357                 stack,

   358                 true,       // clean

   359                 0,          // count

   360                 0,          // index

   361                 false,      // canUndo

   362                 "",         // undoText

   363                 false,      // canRedo

   364                 "",         // redoText

   365                 false,      // cleanChanged

   366                 false,      // indexChanged

   367                 false,      // undoChanged

   368                 false);     // redoChanged

   369 

   370     stack.push(new InsertCommand(&str, 0, "hello"));

   371     QCOMPARE(str, QString("hello"));

   372     checkState(redoTextChangedSpy,

   373                 canRedoChangedSpy,

   374                 undoTextChangedSpy,

   375                 redoAction,

   376                 undoAction,

   377                 canUndoChangedSpy,

   378                 cleanChangedSpy,

   379                 indexChangedSpy,

   380                 stack,

   381                 false,      // clean

   382                 1,          // count

   383                 1,          // index

   384                 true,       // canUndo

   385                 "insert",   // undoText

   386                 false,      // canRedo

   387                 "",         // redoText

   388                 true,       // cleanChanged

   389                 true,       // indexChanged

   390                 true,       // undoChanged

   391                 true);      // redoChanged

   392 

   393     stack.push(new InsertCommand(&str, 2, "123"));

   394     QCOMPARE(str, QString("he123llo"));

   395     checkState(redoTextChangedSpy,

   396                 canRedoChangedSpy,

   397                 undoTextChangedSpy,

   398                 redoAction,

   399                 undoAction,

   400                 canUndoChangedSpy,

   401                 cleanChangedSpy,

   402                 indexChangedSpy,

   403                 stack,

   404                 false,      // clean

   405                 2,          // count

   406                 2,          // index

   407                 true,       // canUndo

   408                 "insert",   // undoText

   409                 false,      // canRedo

   410                 "",         // redoText

   411                 false,      // cleanChanged

   412                 true,       // indexChanged

   413                 true,       // undoChanged

   414                 true);      // redoChanged

   415 

   416 

   417     stack.undo();

   418     QCOMPARE(str, QString("hello"));

   419     checkState(redoTextChangedSpy,

   420                 canRedoChangedSpy,

   421                 undoTextChangedSpy,

   422                 redoAction,

   423                 undoAction,

   424                 canUndoChangedSpy,

   425                 cleanChangedSpy,

   426                 indexChangedSpy,

   427                 stack,

   428                 false,      // clean

   429                 2,          // count

   430                 1,          // index

   431                 true,       // canUndo

   432                 "insert",   // undoText

   433                 true,       // canRedo

   434                 "insert",   // redoText

   435                 false,      // cleanChanged

   436                 true,       // indexChanged

   437                 true,       // undoChanged

   438                 true);      // redoChanged

   439 

   440     stack.redo();

   441     QCOMPARE(str, QString("he123llo"));

   442     checkState(redoTextChangedSpy,

   443                 canRedoChangedSpy,

   444                 undoTextChangedSpy,

   445                 redoAction,

   446                 undoAction,

   447                 canUndoChangedSpy,

   448                 cleanChangedSpy,

   449                 indexChangedSpy,

   450                 stack,

   451                 false,      // clean

   452                 2,          // count

   453                 2,          // index

   454                 true,       // canUndo

   455                 "insert",   // undoText

   456                 false,      // canRedo

   457                 "",         // redoText

   458                 false,      // cleanChanged

   459                 true,       // indexChanged

   460                 true,       // undoChanged

   461                 true);      // redoChanged

   462 

   463     stack.redo(); // nothing to redo

   464     QCOMPARE(str, QString("he123llo"));

   465     checkState(redoTextChangedSpy,

   466                 canRedoChangedSpy,

   467                 undoTextChangedSpy,

   468                 redoAction,

   469                 undoAction,

   470                 canUndoChangedSpy,

   471                 cleanChangedSpy,

   472                 indexChangedSpy,

   473                 stack,

   474                 false,      // clean

   475                 2,          // count

   476                 2,          // index

   477                 true,       // canUndo

   478                 "insert",   // undoText

   479                 false,      // canRedo

   480                 "",         // redoText

   481                 false,      // cleanChanged

   482                 false,      // indexChanged

   483                 false,      // undoChanged

   484                 false);     // redoChanged

   485 

   486     stack.undo();

   487     QCOMPARE(str, QString("hello"));

   488     checkState(redoTextChangedSpy,

   489                 canRedoChangedSpy,

   490                 undoTextChangedSpy,

   491                 redoAction,

   492                 undoAction,

   493                 canUndoChangedSpy,

   494                 cleanChangedSpy,

   495                 indexChangedSpy,

   496                 stack,

   497                 false,      // clean

   498                 2,          // count

   499                 1,          // index

   500                 true,       // canUndo

   501                 "insert",   // undoText

   502                 true,       // canRedo

   503                 "insert",   // redoText

   504                 false,      // cleanChanged

   505                 true,       // indexChanged

   506                 true,       // undoChanged

   507                 true);      // redoChanged

   508 

   509     stack.undo();

   510     QCOMPARE(str, QString());

   511     checkState(redoTextChangedSpy,

   512                 canRedoChangedSpy,

   513                 undoTextChangedSpy,

   514                 redoAction,

   515                 undoAction,

   516                 canUndoChangedSpy,

   517                 cleanChangedSpy,

   518                 indexChangedSpy,

   519                 stack,

   520                 true,       // clean

   521                 2,          // count

   522                 0,          // index

   523                 false,      // canUndo

   524                 "",         // undoText

   525                 true,       // canRedo

   526                 "insert",   // redoText

   527                 true,       // cleanChanged

   528                 true,       // indexChanged

   529                 true,       // undoChanged

   530                 true);      // redoChanged

   531 

   532     stack.undo(); // nothing to undo

   533     QCOMPARE(str, QString());

   534     checkState(redoTextChangedSpy,

   535                 canRedoChangedSpy,

   536                 undoTextChangedSpy,

   537                 redoAction,

   538                 undoAction,

   539                 canUndoChangedSpy,

   540                 cleanChangedSpy,

   541                 indexChangedSpy,

   542                 stack,

   543                 true,       // clean

   544                 2,          // count

   545                 0,          // index

   546                 false,      // canUndo

   547                 "",         // undoText

   548                 true,       // canRedo

   549                 "insert",   // redoText

   550                 false,      // cleanChanged

   551                 false,      // indexChanged

   552                 false,      // undoChanged

   553                 false);     // redoChanged

   554 

   555     // push after undo - check that undone commands get deleted

   556 

   557     stack.redo();

   558     checkState(redoTextChangedSpy,

   559                 canRedoChangedSpy,

   560                 undoTextChangedSpy,

   561                 redoAction,

   562                 undoAction,

   563                 canUndoChangedSpy,

   564                 cleanChangedSpy,

   565                 indexChangedSpy,

   566                 stack,

   567                 false,      // clean

   568                 2,          // count

   569                 1,          // index

   570                 true,       // canUndo

   571                 "insert",   // undoText

   572                 true,       // canRedo

   573                 "insert",   // redoText

   574                 true,       // cleanChanged

   575                 true,       // indexChanged

   576                 true,       // undoChanged

   577                 true);      // redoChanged

   578 

   579     stack.push(new RemoveCommand(&str, 2, 2));

   580     QCOMPARE(str, QString("heo"));

   581     checkState(redoTextChangedSpy,

   582                 canRedoChangedSpy,

   583                 undoTextChangedSpy,

   584                 redoAction,

   585                 undoAction,

   586                 canUndoChangedSpy,

   587                 cleanChangedSpy,

   588                 indexChangedSpy,

   589                 stack,

   590                 false,      // clean

   591                 2,          // count - still 2, last command got deleted

   592                 2,          // index

   593                 true,       // canUndo

   594                 "remove",   // undoText

   595                 false,      // canRedo

   596                 "",         // redoText

   597                 false,      // cleanChanged

   598                 true,       // indexChanged

   599                 true,       // undoChanged

   600                 true);      // redoChanged

   601 

   602     stack.undo();

   603     QCOMPARE(str, QString("hello"));

   604     checkState(redoTextChangedSpy,

   605                 canRedoChangedSpy,

   606                 undoTextChangedSpy,

   607                 redoAction,

   608                 undoAction,

   609                 canUndoChangedSpy,

   610                 cleanChangedSpy,

   611                 indexChangedSpy,

   612                 stack,

   613                 false,      // clean

   614                 2,          // count

   615                 1,          // index

   616                 true,       // canUndo

   617                 "insert",   // undoText

   618                 true,       // canRedo

   619                 "remove",   // redoText

   620                 false,      // cleanChanged

   621                 true,       // indexChanged

   622                 true,       // undoChanged

   623                 true);      // redoChanged

   624 

   625     stack.undo();

   626     QCOMPARE(str, QString());

   627     checkState(redoTextChangedSpy,

   628                 canRedoChangedSpy,

   629                 undoTextChangedSpy,

   630                 redoAction,

   631                 undoAction,

   632                 canUndoChangedSpy,

   633                 cleanChangedSpy,

   634                 indexChangedSpy,

   635                 stack,

   636                 true,       // clean

   637                 2,          // count

   638                 0,          // index

   639                 false,      // canUndo

   640                 "",         // undoText

   641                 true,       // canRedo

   642                 "insert",   // redoText

   643                 true,       // cleanChanged

   644                 true,       // indexChanged

   645                 true,       // undoChanged

   646                 true);      // redoChanged

   647 

   648     stack.push(new InsertCommand(&str, 0, "goodbye"));

   649     QCOMPARE(str, QString("goodbye"));

   650     checkState(redoTextChangedSpy,

   651                 canRedoChangedSpy,

   652                 undoTextChangedSpy,

   653                 redoAction,

   654                 undoAction,

   655                 canUndoChangedSpy,

   656                 cleanChangedSpy,

   657                 indexChangedSpy,

   658                 stack,

   659                 false,      // clean

   660                 1,          // count - two commands got deleted

   661                 1,          // index

   662                 true,       // canUndo

   663                 "insert",   // undoText

   664                 false,      // canRedo

   665                 "",         // redoText

   666                 true,       // cleanChanged

   667                 true,       // indexChanged

   668                 true,       // undoChanged

   669                 true);      // redoChanged

   670 }

   671 

   672 void tst_QUndoStack::setIndex()

   673 {

   674     QUndoStack stack;

   675     QAction *undoAction = stack.createUndoAction(0, QString("foo"));

   676     QAction *redoAction = stack.createRedoAction(0, QString("bar"));

   677     QSignalSpy indexChangedSpy(&stack, SIGNAL(indexChanged(int)));

   678     QSignalSpy cleanChangedSpy(&stack, SIGNAL(cleanChanged(bool)));

   679     QSignalSpy canUndoChangedSpy(&stack, SIGNAL(canUndoChanged(bool)));

   680     QSignalSpy undoTextChangedSpy(&stack, SIGNAL(undoTextChanged(QString)));

   681     QSignalSpy canRedoChangedSpy(&stack, SIGNAL(canRedoChanged(bool)));

   682     QSignalSpy redoTextChangedSpy(&stack, SIGNAL(redoTextChanged(QString)));

   683     QString str;

   684 

   685     stack.setIndex(10); // should do nothing

   686     checkState(redoTextChangedSpy,

   687                 canRedoChangedSpy,

   688                 undoTextChangedSpy,

   689                 redoAction,

   690                 undoAction,

   691                 canUndoChangedSpy,

   692                 cleanChangedSpy,

   693                 indexChangedSpy,

   694                 stack,

   695                 true,       // clean

   696                 0,          // count

   697                 0,          // index

   698                 false,      // canUndo

   699                 "",         // undoText

   700                 false,      // canRedo

   701                 "",         // redoText

   702                 false,      // cleanChanged

   703                 false,      // indexChanged

   704                 false,      // undoChanged

   705                 false);     // redoChanged

   706 

   707     stack.setIndex(0); // should do nothing

   708     checkState(redoTextChangedSpy,

   709                 canRedoChangedSpy,

   710                 undoTextChangedSpy,

   711                 redoAction,

   712                 undoAction,

   713                 canUndoChangedSpy,

   714                 cleanChangedSpy,

   715                 indexChangedSpy,

   716                 stack,

   717                 true,       // clean

   718                 0,          // count

   719                 0,          // index

   720                 false,      // canUndo

   721                 "",         // undoText

   722                 false,      // canRedo

   723                 "",         // redoText

   724                 false,      // cleanChanged

   725                 false,      // indexChanged

   726                 false,      // undoChanged

   727                 false);     // redoChanged

   728 

   729     stack.setIndex(-10); // should do nothing

   730     checkState(redoTextChangedSpy,

   731                 canRedoChangedSpy,

   732                 undoTextChangedSpy,

   733                 redoAction,

   734                 undoAction,

   735                 canUndoChangedSpy,

   736                 cleanChangedSpy,

   737                 indexChangedSpy,

   738                 stack,

   739                 true,       // clean

   740                 0,          // count

   741                 0,          // index

   742                 false,      // canUndo

   743                 "",         // undoText

   744                 false,      // canRedo

   745                 "",         // redoText

   746                 false,      // cleanChanged

   747                 false,      // indexChanged

   748                 false,      // undoChanged

   749                 false);     // redoChanged

   750 

   751     stack.push(new InsertCommand(&str, 0, "hello"));

   752     QCOMPARE(str, QString("hello"));

   753     checkState(redoTextChangedSpy,

   754                 canRedoChangedSpy,

   755                 undoTextChangedSpy,

   756                 redoAction,

   757                 undoAction,

   758                 canUndoChangedSpy,

   759                 cleanChangedSpy,

   760                 indexChangedSpy,

   761                 stack,

   762                 false,      // clean

   763                 1,          // count

   764                 1,          // index

   765                 true,       // canUndo

   766                 "insert",   // undoText

   767                 false,      // canRedo

   768                 "",         // redoText

   769                 true,       // cleanChanged

   770                 true,       // indexChanged

   771                 true,       // undoChanged

   772                 true);      // redoChanged

   773 

   774     stack.push(new InsertCommand(&str, 2, "123"));

   775     QCOMPARE(str, QString("he123llo"));

   776     checkState(redoTextChangedSpy,

   777                 canRedoChangedSpy,

   778                 undoTextChangedSpy,

   779                 redoAction,

   780                 undoAction,

   781                 canUndoChangedSpy,

   782                 cleanChangedSpy,

   783                 indexChangedSpy,

   784                 stack,

   785                 false,      // clean

   786                 2,          // count

   787                 2,          // index

   788                 true,       // canUndo

   789                 "insert",   // undoText

   790                 false,      // canRedo

   791                 "",         // redoText

   792                 false,      // cleanChanged

   793                 true,       // indexChanged

   794                 true,       // undoChanged

   795                 true);      // redoChanged

   796 

   797     stack.setIndex(2);

   798     QCOMPARE(str, QString("he123llo"));

   799     checkState(redoTextChangedSpy,

   800                 canRedoChangedSpy,

   801                 undoTextChangedSpy,

   802                 redoAction,

   803                 undoAction,

   804                 canUndoChangedSpy,

   805                 cleanChangedSpy,

   806                 indexChangedSpy,

   807                 stack,

   808                 false,      // clean

   809                 2,          // count

   810                 2,          // index

   811                 true,       // canUndo

   812                 "insert",   // undoText

   813                 false,      // canRedo

   814                 "",         // redoText

   815                 false,      // cleanChanged

   816                 false,      // indexChanged

   817                 false,      // undoChanged

   818                 false);     // redoChanged

   819 

   820     stack.setIndex(0);

   821     QCOMPARE(str, QString());

   822     checkState(redoTextChangedSpy,

   823                 canRedoChangedSpy,

   824                 undoTextChangedSpy,

   825                 redoAction,

   826                 undoAction,

   827                 canUndoChangedSpy,

   828                 cleanChangedSpy,

   829                 indexChangedSpy,

   830                 stack,

   831                 true,       // clean

   832                 2,          // count

   833                 0,          // index

   834                 false,      // canUndo

   835                 "",         // undoText

   836                 true,       // canRedo

   837                 "insert",   // redoText

   838                 true,       // cleanChanged

   839                 true,       // indexChanged

   840                 true,       // undoChanged

   841                 true);      // redoChanged

   842 

   843     stack.setIndex(10); // should set index to 2

   844     QCOMPARE(str, QString("he123llo"));

   845     checkState(redoTextChangedSpy,

   846                 canRedoChangedSpy,

   847                 undoTextChangedSpy,

   848                 redoAction,

   849                 undoAction,

   850                 canUndoChangedSpy,

   851                 cleanChangedSpy,

   852                 indexChangedSpy,

   853                 stack,

   854                 false,      // clean

   855                 2,          // count

   856                 2,          // index

   857                 true,       // canUndo

   858                 "insert",   // undoText

   859                 false,      // canRedo

   860                 "",         // redoText

   861                 true,       // cleanChanged

   862                 true,       // indexChanged

   863                 true,       // undoChanged

   864                 true);      // redoChanged

   865 

   866     stack.setIndex(-10); // should set index to 0

   867     QCOMPARE(str, QString());

   868     checkState(redoTextChangedSpy,

   869                 canRedoChangedSpy,

   870                 undoTextChangedSpy,

   871                 redoAction,

   872                 undoAction,

   873                 canUndoChangedSpy,

   874                 cleanChangedSpy,

   875                 indexChangedSpy,

   876                 stack,

   877                 true,       // clean

   878                 2,          // count

   879                 0,          // index

   880                 false,      // canUndo

   881                 "",         // undoText

   882                 true,       // canRedo

   883                 "insert",   // redoText

   884                 true,       // cleanChanged

   885                 true,       // indexChanged

   886                 true,       // undoChanged

   887                 true);      // redoChanged

   888 

   889     stack.setIndex(1);

   890     QCOMPARE(str, QString("hello"));

   891     checkState(redoTextChangedSpy,

   892                 canRedoChangedSpy,

   893                 undoTextChangedSpy,

   894                 redoAction,

   895                 undoAction,

   896                 canUndoChangedSpy,

   897                 cleanChangedSpy,

   898                 indexChangedSpy,

   899                 stack,

   900                 false,      // clean

   901                 2,          // count

   902                 1,          // index

   903                 true,       // canUndo

   904                 "insert",   // undoText

   905                 true,       // canRedo

   906                 "insert",   // redoText

   907                 true,       // cleanChanged

   908                 true,       // indexChanged

   909                 true,       // undoChanged

   910                 true);      // redoChanged

   911 

   912     stack.setIndex(2);

   913     QCOMPARE(str, QString("he123llo"));

   914     checkState(redoTextChangedSpy,

   915                 canRedoChangedSpy,

   916                 undoTextChangedSpy,

   917                 redoAction,

   918                 undoAction,

   919                 canUndoChangedSpy,

   920                 cleanChangedSpy,

   921                 indexChangedSpy,

   922                 stack,

   923                 false,      // clean

   924                 2,          // count

   925                 2,          // index

   926                 true,       // canUndo

   927                 "insert",   // undoText

   928                 false,      // canRedo

   929                 "",         // redoText

   930                 false,      // cleanChanged

   931                 true,       // indexChanged

   932                 true,       // undoChanged

   933                 true);      // redoChanged

   934 }

   935 

   936 void tst_QUndoStack::setClean()

   937 {

   938     QUndoStack stack;

   939     QAction *undoAction = stack.createUndoAction(0, QString("foo"));

   940     QAction *redoAction = stack.createRedoAction(0, QString("bar"));

   941     QSignalSpy indexChangedSpy(&stack, SIGNAL(indexChanged(int)));

   942     QSignalSpy cleanChangedSpy(&stack, SIGNAL(cleanChanged(bool)));

   943     QSignalSpy canUndoChangedSpy(&stack, SIGNAL(canUndoChanged(bool)));

   944     QSignalSpy undoTextChangedSpy(&stack, SIGNAL(undoTextChanged(QString)));

   945     QSignalSpy canRedoChangedSpy(&stack, SIGNAL(canRedoChanged(bool)));

   946     QSignalSpy redoTextChangedSpy(&stack, SIGNAL(redoTextChanged(QString)));

   947     QString str;

   948 

   949     QCOMPARE(stack.cleanIndex(), 0);

   950     stack.setClean();

   951     checkState(redoTextChangedSpy,

   952                 canRedoChangedSpy,

   953                 undoTextChangedSpy,

   954                 redoAction,

   955                 undoAction,

   956                 canUndoChangedSpy,

   957                 cleanChangedSpy,

   958                 indexChangedSpy,

   959                 stack,

   960                 true,       // clean

   961                 0,          // count

   962                 0,          // index

   963                 false,      // canUndo

   964                 "",         // undoText

   965                 false,      // canRedo

   966                 "",         // redoText

   967                 false,      // cleanChanged

   968                 false,      // indexChanged

   969                 false,      // undoChanged

   970                 false);     // redoChanged

   971     QCOMPARE(stack.cleanIndex(), 0);

   972 

   973     stack.push(new InsertCommand(&str, 0, "goodbye"));

   974     checkState(redoTextChangedSpy,

   975                 canRedoChangedSpy,

   976                 undoTextChangedSpy,

   977                 redoAction,

   978                 undoAction,

   979                 canUndoChangedSpy,

   980                 cleanChangedSpy,

   981                 indexChangedSpy,

   982                 stack,

   983                 false,      // clean

   984                 1,          // count

   985                 1,          // index

   986                 true,       // canUndo

   987                 "insert",   // undoText

   988                 false,      // canRedo

   989                 "",         // redoText

   990                 true,       // cleanChanged

   991                 true,       // indexChanged

   992                 true,       // undoChanged

   993                 true);      // redoChanged

   994     QCOMPARE(stack.cleanIndex(), 0);

   995 

   996     stack.setClean();

   997     QCOMPARE(str, QString("goodbye"));

   998     checkState(redoTextChangedSpy,

   999                 canRedoChangedSpy,

  1000                 undoTextChangedSpy,

  1001                 redoAction,

  1002                 undoAction,

  1003                 canUndoChangedSpy,

  1004                 cleanChangedSpy,

  1005                 indexChangedSpy,

  1006                 stack,

  1007                 true,       // clean

  1008                 1,          // count

  1009                 1,          // index

  1010                 true,       // canUndo

  1011                 "insert",   // undoText

  1012                 false,      // canRedo

  1013                 "",         // redoText

  1014                 true,       // cleanChanged

  1015                 false,      // indexChanged

  1016                 false,      // undoChanged

  1017                 false);     // redoChanged

  1018     QCOMPARE(stack.cleanIndex(), 1);

  1019 

  1020     stack.push(new AppendCommand(&str, " cowboy"));

  1021     QCOMPARE(str, QString("goodbye cowboy"));

  1022     checkState(redoTextChangedSpy,

  1023                 canRedoChangedSpy,

  1024                 undoTextChangedSpy,

  1025                 redoAction,

  1026                 undoAction,

  1027                 canUndoChangedSpy,

  1028                 cleanChangedSpy,

  1029                 indexChangedSpy,

  1030                 stack,

  1031                 false,      // clean

  1032                 2,          // count

  1033                 2,          // index

  1034                 true,       // canUndo

  1035                 "append",   // undoText

  1036                 false,      // canRedo

  1037                 "",         // redoText

  1038                 true,       // cleanChanged

  1039                 true,       // indexChanged

  1040                 true,       // undoChanged

  1041                 true);      // redoChanged

  1042     QCOMPARE(stack.cleanIndex(), 1);

  1043 

  1044     stack.undo(); // reaching clean state from above

  1045     QCOMPARE(str, QString("goodbye"));

  1046     checkState(redoTextChangedSpy,

  1047                 canRedoChangedSpy,

  1048                 undoTextChangedSpy,

  1049                 redoAction,

  1050                 undoAction,

  1051                 canUndoChangedSpy,

  1052                 cleanChangedSpy,

  1053                 indexChangedSpy,

  1054                 stack,

  1055                 true,      // clean

  1056                 2,          // count

  1057                 1,          // index

  1058                 true,       // canUndo

  1059                 "insert",   // undoText

  1060                 true,       // canRedo

  1061                 "append",   // redoText

  1062                 true,       // cleanChanged

  1063                 true,       // indexChanged

  1064                 true,       // undoChanged

  1065                 true);      // redoChanged

  1066     QCOMPARE(stack.cleanIndex(), 1);

  1067 

  1068     stack.undo();

  1069     QCOMPARE(str, QString());

  1070     checkState(redoTextChangedSpy,

  1071                 canRedoChangedSpy,

  1072                 undoTextChangedSpy,

  1073                 redoAction,

  1074                 undoAction,

  1075                 canUndoChangedSpy,

  1076                 cleanChangedSpy,

  1077                 indexChangedSpy,

  1078                 stack,

  1079                 false,      // clean

  1080                 2,          // count

  1081                 0,          // index

  1082                 false,      // canUndo

  1083                 "",         // undoText

  1084                 true,       // canRedo

  1085                 "insert",   // redoText

  1086                 true,       // cleanChanged

  1087                 true,       // indexChanged

  1088                 true,       // undoChanged

  1089                 true);      // redoChanged

  1090     QCOMPARE(stack.cleanIndex(), 1);

  1091 

  1092     stack.redo(); // reaching clean state from below

  1093     QCOMPARE(str, QString("goodbye"));

  1094     checkState(redoTextChangedSpy,

  1095                 canRedoChangedSpy,

  1096                 undoTextChangedSpy,

  1097                 redoAction,

  1098                 undoAction,

  1099                 canUndoChangedSpy,

  1100                 cleanChangedSpy,

  1101                 indexChangedSpy,

  1102                 stack,

  1103                 true,       // clean

  1104                 2,          // count

  1105                 1,          // index

  1106                 true,       // canUndo

  1107                 "insert",   // undoText

  1108                 true,       // canRedo

  1109                 "append",   // redoText

  1110                 true,       // cleanChanged

  1111                 true,       // indexChanged

  1112                 true,       // undoChanged

  1113                 true);      // redoChanged

  1114     QCOMPARE(stack.cleanIndex(), 1);

  1115 

  1116     stack.undo();

  1117     QCOMPARE(str, QString());

  1118     checkState(redoTextChangedSpy,

  1119                 canRedoChangedSpy,

  1120                 undoTextChangedSpy,

  1121                 redoAction,

  1122                 undoAction,

  1123                 canUndoChangedSpy,

  1124                 cleanChangedSpy,

  1125                 indexChangedSpy,

  1126                 stack,

  1127                 false,      // clean

  1128                 2,          // count

  1129                 0,          // index

  1130                 false,      // canUndo

  1131                 "",         // undoText

  1132                 true,       // canRedo

  1133                 "insert",   // redoText

  1134                 true,       // cleanChanged