tests/MockCliEvent.cpp

   1 /*
   2 * Copyright (C) 2011 Tomáš Hubík <hubik.tomas@gmail.com>
   3 *
   4 * This file is part of the Deska, a tool for central administration of a grid site
   5 * http://projects.flaska.net/projects/show/deska
   6 *
   7 * This program is free software; you can redistribute it and/or
   8 * modify it under the terms of the GNU General Public
   9 * License as published by the Free Software Foundation; either
  10 * version 2 of the License, or the version 3 of the License.
  11 *
  12 * This program is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 * General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; see the file COPYING.  If not, write to
  19 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20 * Boston, MA 02110-1301, USA.
  21 * */
  22
  23
  24 #include <iostream>
  25 #include "MockCliEvent.h"
  26 #include "FuzzyDeskaValue.h"
  27
  28
  29 bool testChangesetsEqual(const Deska::Db::PendingChangeset &a, const Deska::Db::PendingChangeset &b)
  30 {
  31     return a.revision == b.revision && a.author == b.author &&
  32            a.parentRevision == b.parentRevision && a.message == b.message &&
  33            a.attachStatus == b.attachStatus && a.activeConnectionInfo == b.activeConnectionInfo;
  34 }
  35
  36
  37
  38 bool testRevisionsEqual(const Deska::Db::RevisionMetadata &a, const Deska::Db::RevisionMetadata &b)
  39 {
  40     return a.revision == b.revision && a.author == b.author && a.timestamp == b.timestamp &&
  41            a.commitMessage == b.commitMessage;
  42 }
  43
  44 bool fuzzyTestValueAttrEqual(const Deska::Cli::AttributeDefinition &a, const Deska::Cli::AttributeDefinition &b)
  45 {
  46     if (a.attribute != b.attribute)
  47         return false;
  48     if ((a.value && !b.value) || (!a.value && b.value))
  49         return false;
  50     if (!a.value && !b.value)
  51         return true;
  52     BOOST_ASSERT(a.value && b.value);
  53
  54     boost::apply_visitor(FuzzyTestCompareDeskaValue(), *(a.value), *(b.value));
  55     // The visitor asserts if it's different
  56     return true;
  57 }
  58
  59 bool fuzzyTestValueAttrOrigEqual(const std::pair<Deska::Cli::AttributeDefinition, Deska::Db::Identifier> &a,
  60                          const std::pair<Deska::Cli::AttributeDefinition, Deska::Db::Identifier> &b)
  61 {
  62     return (a.second == b.second) && fuzzyTestValueAttrEqual(a.first, b.first);
  63 }
  64
  65
  66 MockCliEvent MockCliEvent::reportError(const std::string &errorMessage)
  67 {
  68     MockCliEvent res(EVENT_REPORT_ERROR);
  69     res.str1 = errorMessage;
  70     return res;
  71 }
  72
  73
  74
  75 MockCliEvent MockCliEvent::printMessage(const std::string &message)
  76 {
  77     MockCliEvent res(EVENT_PRINT_MESSAGE);
  78     res.str1 = message;
  79     return res;
  80 }
  81
  82
  83
  84 MockCliEvent MockCliEvent::displayInPager(const std::string &message)
  85 {
  86     MockCliEvent res(EVENT_DISPALY_IN_PAGER);
  87     res.str1 = message;
  88     return res;
  89 }
  90
  91
  92
  93 MockCliEvent MockCliEvent::editFile(const std::string &fileName)
  94 {
  95     MockCliEvent res(EVENT_EDIT_FILE);
  96     res.str1 = fileName;
  97     return res;
  98 }
  99
 100
 101
 102 MockCliEvent MockCliEvent::confirmDeletion(const Deska::Cli::ObjectDefinition &object)
 103 {
 104     MockCliEvent res(EVENT_CONFIRM_DELETION);
 105     res.object = object;
 106     return res;
 107 }
 108
 109
 110
 111 MockCliEvent MockCliEvent::returnConfirmDeletion(bool confirm)
 112 {
 113     MockCliEvent res(RETURN_CONFIRM_DELETION);
 114     res.boolean = confirm;
 115     return res;
 116 }
 117
 118
 119
 120 MockCliEvent MockCliEvent::confirmDeletionNested(const std::vector<Deska::Cli::ObjectDefinition> &nestedObjects)
 121 {
 122     MockCliEvent res(EVENT_CONFIRM_DELETION_NESTED);
 123     res.objects = nestedObjects;
 124     return res;
 125 }
 126
 127
 128
 129 MockCliEvent MockCliEvent::returnConfirmDeletionNested(bool confirm)
 130 {
 131     MockCliEvent res(RETURN_CONFIRM_DELETION_NESTED);
 132     res.boolean = confirm;
 133     return res;
 134 }
 135
 136
 137
 138 MockCliEvent MockCliEvent::confirmDeletionConnected(const std::vector<Deska::Cli::ObjectDefinition> &connectedObjects)
 139 {
 140     MockCliEvent res(EVENT_CONFIRM_DELETION_CONNECTED);
 141     res.objects = connectedObjects;
 142     return res;
 143 }
 144
 145
 146
 147 MockCliEvent MockCliEvent::returnConfirmDeletionConnected(bool confirm)
 148 {
 149     MockCliEvent res(RETURN_CONFIRM_DELETION_CONNECTED);
 150     res.boolean = confirm;
 151     return res;
 152 }
 153
 154
 155 MockCliEvent MockCliEvent::confirmRenameConnected(const std::vector<Deska::Cli::ObjectDefinition> &connectedObjects)
 156 {
 157     MockCliEvent res(EVENT_CONFIRM_RENAME_CONNECTED);
 158     res.objects = connectedObjects;
 159     return res;
 160 }
 161
 162
 163
 164 MockCliEvent MockCliEvent::returnConfirmRenameConnected(bool confirm)
 165 {
 166     MockCliEvent res(RETURN_CONFIRM_RENAME_CONNECTED);
 167     res.boolean = confirm;
 168     return res;
 169 }
 170
 171
 172
 173 MockCliEvent MockCliEvent::confirmCreation(const Deska::Cli::ObjectDefinition &object)
 174 {
 175     MockCliEvent res(EVENT_CONFIRM_CREATION);
 176     res.object = object;
 177     return res;
 178 }
 179
 180
 181
 182 MockCliEvent MockCliEvent::returnConfirmCreation(bool confirm)
 183 {
 184     MockCliEvent res(RETURN_CONFIRM_CREATION);
 185     res.boolean = confirm;
 186     return res;
 187 }
 188
 189
 190
 191 MockCliEvent MockCliEvent::confirmCreationConnection(const Deska::Cli::ObjectDefinition &object)
 192 {
 193     MockCliEvent res(EVENT_CONFIRM_CREATION_CONNECTION_1);
 194     res.object = object;
 195     return res;
 196 }
 197
 198
 199
 200 MockCliEvent MockCliEvent::returnConfirmCreationConnection1(bool confirm)
 201 {
 202     MockCliEvent res(RETURN_CONFIRM_CREATION_CONNECTION_1);
 203     res.boolean = confirm;
 204     return res;
 205 }
 206
 207
 208
 209 MockCliEvent MockCliEvent::confirmCreationConnection(const Deska::Cli::ObjectDefinition &object, const std::vector<Deska::Cli::ObjectDefinition> &connectedObjects)
 210 {
 211     MockCliEvent res(EVENT_CONFIRM_CREATION_CONNECTION_2);
 212     res.objects = connectedObjects;
 213     res.object = object;
 214     return res;
 215 }
 216
 217
 218
 219 MockCliEvent MockCliEvent::returnConfirmCreationConnection2(bool confirm)
 220 {
 221     MockCliEvent res(RETURN_CONFIRM_CREATION_CONNECTION_2);
 222     res.boolean = confirm;
 223     return res;
 224 }
 225
 226
 227
 228 MockCliEvent MockCliEvent::confirmRestoration(const Deska::Cli::ObjectDefinition &object)
 229 {
 230     MockCliEvent res(EVENT_CONFIRM_RESTORATION);
 231     res.object = object;
 232     return res;
 233 }
 234
 235
 236
 237 MockCliEvent MockCliEvent::returnConfirmRestoration(bool confirm)
 238 {
 239     MockCliEvent res(RETURN_CONFIRM_RESTORATION);
 240     res.boolean = confirm;
 241     return res;
 242 }
 243
 244
 245
 246 MockCliEvent MockCliEvent::askForConfirmation(const std::string &message)
 247 {
 248     MockCliEvent res(EVENT_ASK_FOR_CONFIRMATION);
 249     res.str1 = message;
 250     return res;
 251 }
 252
 253
 254
 255 MockCliEvent MockCliEvent::returnAskForConfirmation(bool confirmed)
 256 {
 257     MockCliEvent res(RETURN_ASK_FOR_CONFIRMATION);
 258     res.boolean = confirmed;
 259     return res;
 260 }
 261
 262
 263
 264 MockCliEvent MockCliEvent::askForCommitMessage()
 265 {
 266     return MockCliEvent(EVENT_ASK_FOR_COMMIT_MESSAGE);
 267 }
 268
 269
 270
 271 MockCliEvent MockCliEvent::returnAskForCommitMessage(const std::string &message)
 272 {
 273     MockCliEvent res(RETURN_ASK_FOR_COMMIT_MESSAGE);
 274     res.str1 = message;
 275     return res;
 276 }
 277
 278
 279
 280 MockCliEvent MockCliEvent::askForDetachMessage()
 281 {
 282     return MockCliEvent(EVENT_ASK_FOR_DETACH_MESSAGE);
 283 }
 284
 285
 286
 287 MockCliEvent MockCliEvent::returnAskForDetachMessage(const std::string &message)
 288 {
 289     MockCliEvent res(RETURN_ASK_FOR_DETACH_MESSAGE);
 290     res.str1 = message;
 291     return res;
 292 }
 293
 294
 295
 296 MockCliEvent MockCliEvent::printHelp(const std::map<std::string, std::string> &cliCommands,
 297                                      const std::map<std::string, std::string> &parserKeywords)
 298 {
 299     MockCliEvent res(EVENT_PRINT_HELP);
 300     res.map1 = cliCommands;
 301     res.map2 = parserKeywords;
 302     return res;
 303 }
 304
 305
 306
 307 MockCliEvent MockCliEvent::printHelpCommand(const std::string &cmdName, const std::string &cmdDscr)
 308 {
 309     MockCliEvent res(EVENT_PRINT_HELP_COMMAND);
 310     res.str1 = cmdName;
 311     res.str2 = cmdDscr;
 312     return res;
 313 }
 314
 315
 316
 317 MockCliEvent MockCliEvent::printHelpKeyword(const std::string &keywordName, const std::string &keywordDscr)
 318 {
 319     MockCliEvent res(EVENT_PRINT_HELP_KEYWORD);
 320     res.str1 = keywordName;
 321     res.str2 = keywordDscr;
 322     return res;
 323 }
 324
 325
 326
 327 MockCliEvent MockCliEvent::printHelpKind(const std::string &kindName,
 328                                          const std::vector<std::pair<std::string, std::string> > &kindAttrs,
 329                                          const std::vector<std::string> &nestedKinds,
 330                                          const std::vector<std::pair<std::string, std::string> > &containedKinds,
 331                                          const std::vector<std::pair<std::string, std::string> > &containableKinds)
 332 {
 333     MockCliEvent res(EVENT_PRINT_HELP_KIND);
 334     res.str1 = kindName;
 335     res.vectpair1 = kindAttrs;
 336     res.vectpair2 = containedKinds;
 337     res.vectpair3 = containableKinds;
 338     res.vect = nestedKinds;
 339     return res;
 340 }
 341
 342
 343
 344 MockCliEvent MockCliEvent::printHelpShowKinds(const std::vector<std::string> &kinds)
 345 {
 346     MockCliEvent res(EVENT_PRINT_HELP_SHOW_KINDS);
 347     res.vect = kinds;
 348     return res;
 349 }
 350
 351
 352
 353 MockCliEvent MockCliEvent::chooseChangeset(const std::vector<Deska::Db::PendingChangeset> &pendingChangesets)
 354 {
 355     MockCliEvent res(EVENT_CHOOSE_CHANGESET);
 356     res.changesets = pendingChangesets;
 357     return res;
 358 }
 359
 360
 361
 362 MockCliEvent MockCliEvent::returnChooseChangeset(int changeset)
 363 {
 364     MockCliEvent res(RETURN_CHOOSE_CHANGESET);
 365     res.integer = changeset;
 366     return res;
 367 }
 368
 369
 370
 371 MockCliEvent MockCliEvent::readLine(const std::string &prompt)
 372 {
 373     MockCliEvent res(EVENT_READ_LINE);
 374     res.str1 = prompt;
 375     return res;
 376 }
 377
 378
 379
 380 MockCliEvent MockCliEvent::returnReadLine(const std::pair<std::string, bool> &line)
 381 {
 382     MockCliEvent res(RETURN_READ_LINE);
 383     res.strbool = line;
 384     return res;
 385 }
 386
 387
 388
 389 MockCliEvent MockCliEvent::printAttributes(const std::vector<Deska::Cli::AttributeDefinition> &attributes, int indentLevel,
 390                                            std::ostream &out)
 391 {
 392     MockCliEvent res(EVENT_PRINT_ATTRIBUTES);
 393     res.attrs = attributes;
 394     res.integer = indentLevel;
 395     return res;
 396 }
 397
 398
 399
 400 MockCliEvent MockCliEvent::printAttribute(const Deska::Cli::AttributeDefinition &attribute, int indentLevel,
 401                                           std::ostream &out)
 402 {
 403     MockCliEvent res(EVENT_PRINT_ATTRIBUTE);
 404     res.attr = attribute;
 405     res.integer = indentLevel;
 406     return res;
 407 }
 408
 409
 410
 411 MockCliEvent MockCliEvent::printAttributesWithOrigin(
 412     const std::vector<std::pair<Deska::Cli::AttributeDefinition, Deska::Db::Identifier> > &attributes,
 413     int indentLevel, std::ostream &out)
 414 {
 415     MockCliEvent res(EVENT_PRINT_ATTRIBUTES_WITH_ORIGIN);
 416     res.attrsorig = attributes;
 417     res.integer = indentLevel;
 418     return res;
 419 }
 420
 421
 422
 423 MockCliEvent MockCliEvent::printAttributeWithOrigin(const Deska::Cli::AttributeDefinition &attribute,
 424                                                     const Deska::Db::Identifier &origin, int indentLevel,
 425                                                     std::ostream &out)
 426 {
 427     MockCliEvent res(EVENT_PRINT_ATTRIBUTE_WITH_ORIGIN);
 428     res.ident = origin;
 429     res.attr = attribute;
 430     res.integer = indentLevel;
 431     return res;
 432 }
 433
 434
 435
 436 MockCliEvent MockCliEvent::printObjects(const std::vector<Deska::Cli::ObjectDefinition> &objects, int indentLevel,
 437                                         bool fullName, std::ostream &out)
 438 {
 439     MockCliEvent res(EVENT_PRINT_OBJECTS);
 440     res.objects = objects;
 441     res.integer = indentLevel;
 442     return res;
 443 }
 444
 445
 446
 447 MockCliEvent MockCliEvent::printObject(const Deska::Cli::ObjectDefinition &object, int indentLevel, bool fullName,
 448                                        std::ostream &out)
 449 {
 450     MockCliEvent res(EVENT_PRINT_OBJECT);
 451     res.object = object;
 452     res.integer = indentLevel;
 453     return res;
 454 }
 455
 456
 457
 458 MockCliEvent MockCliEvent::printEnd(int indentLevel, std::ostream &out)
 459 {
 460     MockCliEvent res(EVENT_PRINT_END);
 461     res.integer = indentLevel;
 462     return res;
 463 }
 464
 465
 466
 467 MockCliEvent MockCliEvent::printRevisions(const std::vector<Deska::Db::RevisionMetadata> &allRevisions)
 468 {
 469     MockCliEvent res(EVENT_PRINT_REVISIONS);
 470     res.revisions = allRevisions;
 471     return res;
 472 }
 473
 474
 475
 476 MockCliEvent MockCliEvent::printDiff(const std::vector<Deska::Db::ObjectModificationResult> &objectsModifiactions)
 477 {
 478     MockCliEvent res(EVENT_PRINT_DIFF);
 479     res.diff = objectsModifiactions;
 480     return res;
 481 }
 482
 483
 484
 485 MockCliEvent MockCliEvent::addCommandCompletion(const std::string &completion)
 486 {
 487     MockCliEvent res(EVENT_ADD_COMMAND_COMPLETION);
 488     res.str1 = completion;
 489     return res;
 490 }
 491
 492
 493
 494 MockCliEvent MockCliEvent::invalid()
 495 {
 496     return MockCliEvent(EVENT_INVALID);
 497 }
 498
 499
 500
 501 bool MockCliEvent::inputEvent(const MockCliEvent &m) const
 502 {
 503     return ((m.eventKind == RETURN_CONFIRM_DELETION) || (m.eventKind == RETURN_CONFIRM_DELETION_NESTED)||
 504             (m.eventKind == RETURN_CONFIRM_DELETION_CONNECTED) || (m.eventKind == RETURN_CONFIRM_RENAME_CONNECTED) ||
 505             (m.eventKind == RETURN_CONFIRM_CREATION) || (m.eventKind == RETURN_CONFIRM_CREATION_CONNECTION_1) ||
 506             (m.eventKind == RETURN_CONFIRM_CREATION_CONNECTION_2) || (m.eventKind == RETURN_CONFIRM_RESTORATION) ||
 507             (m.eventKind == RETURN_ASK_FOR_COMMIT_MESSAGE) || (m.eventKind == RETURN_ASK_FOR_DETACH_MESSAGE) ||
 508             (m.eventKind == RETURN_CHOOSE_CHANGESET) || (m.eventKind == RETURN_READ_LINE));
 509 }
 510
 511
 512
 513 bool MockCliEvent::outputEvent(const MockCliEvent &m) const
 514 {
 515     return !(inputEvent(m));
 516 }
 517
 518
 519
 520 bool MockCliEvent::myReturn(const MockCliEvent &other) const
 521 {
 522     // Note that we're comparing EVENT_* against a matching RETURN_*
 523     switch (eventKind) {
 524     case EVENT_CONFIRM_DELETION:
 525         return other.eventKind == RETURN_CONFIRM_DELETION;
 526     case EVENT_CONFIRM_DELETION_NESTED:
 527         return other.eventKind == RETURN_CONFIRM_DELETION_NESTED;
 528     case EVENT_CONFIRM_DELETION_CONNECTED:
 529         return other.eventKind == RETURN_CONFIRM_DELETION_CONNECTED;
 530     case EVENT_CONFIRM_RENAME_CONNECTED:
 531         return other.eventKind == RETURN_CONFIRM_RENAME_CONNECTED;
 532     case EVENT_CONFIRM_CREATION:
 533         return other.eventKind == RETURN_CONFIRM_CREATION;
 534     case EVENT_CONFIRM_CREATION_CONNECTION_1:
 535         return other.eventKind == RETURN_CONFIRM_CREATION_CONNECTION_1;
 536     case EVENT_CONFIRM_CREATION_CONNECTION_2:
 537         return other.eventKind == RETURN_CONFIRM_CREATION_CONNECTION_2;
 538     case EVENT_CONFIRM_RESTORATION:
 539         return other.eventKind == RETURN_CONFIRM_RESTORATION;
 540     case EVENT_ASK_FOR_CONFIRMATION:
 541         return other.eventKind == RETURN_ASK_FOR_CONFIRMATION;
 542     case EVENT_ASK_FOR_COMMIT_MESSAGE:
 543         return other.eventKind == RETURN_ASK_FOR_COMMIT_MESSAGE;
 544     case EVENT_ASK_FOR_DETACH_MESSAGE:
 545         return other.eventKind == RETURN_ASK_FOR_DETACH_MESSAGE;
 546     case EVENT_CHOOSE_CHANGESET:
 547         return other.eventKind == RETURN_CHOOSE_CHANGESET;
 548     case EVENT_READ_LINE:
 549         return other.eventKind == RETURN_READ_LINE;
 550     default:
 551         return false;
 552     }
 553 }
 554
 555
 556
 557 bool MockCliEvent::operator==(const MockCliEvent &other) const
 558 {
 559     return eventKind == other.eventKind && str1 == other.str1 && str2 == other.str2 && integer == other.integer &&
 560            boolean == other.boolean && object == other.object && attr == other.attr && ident == other.ident &&
 561            strbool == other.strbool &&
 562            std::equal(map1.begin(), map1.end(), other.map1.begin()) &&
 563            std::equal(map2.begin(), map2.end(), other.map2.begin()) &&
 564            std::equal(vectpair1.begin(), vectpair1.end(), other.vectpair1.begin()) &&
 565            std::equal(vectpair2.begin(), vectpair2.end(), other.vectpair2.begin()) &&
 566            std::equal(vectpair3.begin(), vectpair3.end(), other.vectpair3.begin()) &&
 567            std::equal(vect.begin(), vect.end(), other.vect.begin()) &&
 568            std::equal(changesets.begin(), changesets.end(), other.changesets.begin(), testChangesetsEqual) &&
 569            std::equal(revisions.begin(), revisions.end(), other.revisions.begin(), testRevisionsEqual) &&
 570            std::equal(diff.begin(), diff.end(), other.diff.begin()) &&
 571            std::equal(attrs.begin(), attrs.end(), other.attrs.begin(), fuzzyTestValueAttrEqual) &&
 572            std::equal(attrsorig.begin(), attrsorig.end(), other.attrsorig.begin(), fuzzyTestValueAttrOrigEqual) &&
 573            std::equal(objects.begin(), objects.end(), other.objects.begin());
 574 }
 575
 576
 577
 578 MockCliEvent::MockCliEvent(Event e): eventKind(e), integer(int()), boolean(bool())
 579 {
 580 }
 581
 582
 583
 584 std::ostream& operator<<(std::ostream &out, const std::map<std::string, std::string> &m)
 585 {
 586     out << "[";
 587     for (std::map<std::string, std::string>::const_iterator it = m.begin(); it != m.end(); ++it) {
 588         if (it != m.begin())
 589             out << ", ";
 590         out << "\"" << it->first << "\":\"" << it->second << "\"";
 591     }
 592     out << "]";
 593     return out;
 594 }
 595
 596
 597
 598 std::ostream& operator<<(std::ostream &out, const std::vector<std::pair<std::string, std::string> > &v)
 599 {
 600     out << "[";
 601     for (std::vector<std::pair<std::string, std::string> >::const_iterator it = v.begin(); it != v.end(); ++it) {
 602         if (it != v.begin())
 603             out << ", ";
 604         out << "\"" << it->first << "\":\"" << it->second << "\"";
 605     }
 606     out << "]";
 607     return out;
 608 }
 609
 610
 611
 612 std::ostream& operator<<(std::ostream &out, const std::vector<std::string> &v)
 613 {
 614     out << "[";
 615     for (std::vector<std::string>::const_iterator it = v.begin(); it != v.end(); ++it) {
 616         if (it != v.begin())
 617             out << ", ";
 618         out << "\"" << *it << "\"";
 619     }
 620     out << "]";
 621     return out;
 622 }
 623
 624
 625
 626 std::ostream& operator<<(std::ostream &out,
 627                          const std::vector<std::pair<Deska::Cli::AttributeDefinition, Deska::Db::Identifier> > &v)
 628 {
 629     out << "[";
 630     for (std::vector<std::pair<Deska::Cli::AttributeDefinition, Deska::Db::Identifier> >::const_iterator it = v.begin();
 631          it != v.end(); ++it) {
 632         if (it != v.begin())
 633             out << ", ";
 634         if (it->second.empty())
 635             out << it->first;
 636         else
 637             out << it->first << "->" << it->second;
 638     }
 639     out << "]";
 640     return out;
 641 }
 642
 643
 644
 645 template <typename T>
 646 std::ostream& operator<<(std::ostream &out, const std::vector<T> &v)
 647 {
 648     out << "[";
 649     for (typename std::vector<T>::const_iterator it = v.begin(); it != v.end(); ++it) {
 650         if (it != v.begin())
 651             out << ", ";
 652         out << *it;
 653     }
 654     out << "]";
 655     return out;
 656 }
 657
 658
 659
 660 std::ostream& operator<<(std::ostream &out, const MockCliEvent &m)
 661 {
 662     switch (m.eventKind) {
 663     case MockCliEvent::EVENT_REPORT_ERROR:
 664         out << "reportError( \"" << m.str1 << "\" )";
 665         break;
 666     case MockCliEvent::EVENT_PRINT_MESSAGE:
 667         out << "printMessage( \"" << m.str1 << "\" )";
 668         break;
 669     case MockCliEvent::EVENT_DISPALY_IN_PAGER:
 670         out << "displayInPager( \"" << m.str1 << "\" )";
 671         break;
 672     case MockCliEvent::EVENT_EDIT_FILE:
 673         out << "editFile( \"" << m.str1 << "\" )";
 674         break;
 675     case MockCliEvent::EVENT_CONFIRM_DELETION:
 676         out << "confirmDeletion( " << *(m.object) << " )";
 677         break;
 678     case MockCliEvent::RETURN_CONFIRM_DELETION:
 679         out << "returnConfirmDeletion( " << m.boolean << " )";
 680         break;
 681     case MockCliEvent::EVENT_CONFIRM_DELETION_NESTED:
 682         out << "confirmDeletionNested( " << m.objects << " )";
 683         break;
 684     case MockCliEvent::RETURN_CONFIRM_DELETION_NESTED:
 685         out << "returnconfirmDeletionNested( " << m.boolean << " )";
 686         break;
 687     case MockCliEvent::EVENT_CONFIRM_DELETION_CONNECTED:
 688         out << "confirmDeletionConnected( " << m.objects << " )";
 689         break;
 690     case MockCliEvent::RETURN_CONFIRM_DELETION_CONNECTED:
 691         out << "returnconfirmDeletionConnected( " << m.boolean << " )";
 692         break;
 693     case MockCliEvent::EVENT_CONFIRM_RENAME_CONNECTED:
 694         out << "confirmRenameConnected( " << m.objects << " )";
 695         break;
 696     case MockCliEvent::RETURN_CONFIRM_RENAME_CONNECTED:
 697         out << "returnconfirmRenameConnected( " << m.boolean << " )";
 698         break;
 699     case MockCliEvent::EVENT_CONFIRM_CREATION:
 700         out << "confirmCreation( " << *(m.object) << " )";
 701         break;
 702     case MockCliEvent::RETURN_CONFIRM_CREATION:
 703         out << "returnConfirmCreation( " << m.boolean << " )";
 704         break;
 705     case MockCliEvent::EVENT_CONFIRM_CREATION_CONNECTION_1:
 706         out << "confirmCreationConnection( " << *(m.object) << " )";
 707         break;
 708     case MockCliEvent::RETURN_CONFIRM_CREATION_CONNECTION_1:
 709         out << "returnConfirmCreation( " << m.boolean << " )";
 710         break;
 711     case MockCliEvent::EVENT_CONFIRM_CREATION_CONNECTION_2:
 712         out << "confirmCreationConnection( " << *(m.object) << ", " << m.objects << " )";
 713         break;
 714     case MockCliEvent::RETURN_CONFIRM_CREATION_CONNECTION_2:
 715         out << "returnConfirmCreation( " << m.boolean << " )";
 716         break;
 717     case MockCliEvent::EVENT_CONFIRM_RESTORATION:
 718         out << "confirmRestoration( " << *(m.object) << " )";
 719         break;
 720     case MockCliEvent::RETURN_CONFIRM_RESTORATION:
 721         out << "returnConfirmRestoration( " << m.boolean << " )";
 722         break;
 723     case MockCliEvent::EVENT_ASK_FOR_CONFIRMATION:
 724         out << "askForConfirmation( \"" << m.str1 << "\" )";
 725         break;
 726     case MockCliEvent::RETURN_ASK_FOR_CONFIRMATION:
 727         out << "returnAskForConfirmation( " << m.boolean << " )";
 728         break;
 729     case MockCliEvent::EVENT_ASK_FOR_COMMIT_MESSAGE:
 730         out << "askForCommitMessage()";
 731         break;
 732     case MockCliEvent::RETURN_ASK_FOR_COMMIT_MESSAGE:
 733         out << "returnAskForCommitMessage( \"" << m.str1 << "\" )";
 734         break;
 735     case MockCliEvent::EVENT_ASK_FOR_DETACH_MESSAGE:
 736         out << "askForDetachMessage()";
 737         break;
 738     case MockCliEvent::RETURN_ASK_FOR_DETACH_MESSAGE:
 739         out << "returnAskForDetachMessage( \"" << m.str1 << "\" )";
 740         break;
 741     case MockCliEvent::EVENT_PRINT_HELP:
 742         out << "printHelp( " << m.map1 << ", " << m.map2 << " )";
 743         break;
 744     case MockCliEvent::EVENT_PRINT_HELP_COMMAND:
 745         out << "printHelpCommand( \"" << m.str1 << "\", \"" << m.str2 << "\" )";
 746         break;
 747     case MockCliEvent::EVENT_PRINT_HELP_KEYWORD:
 748         out << "printHelpKeyword( \"" << m.str1 << "\", \"" << m.str2 << "\" )";
 749         break;
 750     case MockCliEvent::EVENT_PRINT_HELP_KIND:
 751         out << "printHelpKind( \"" << m.str1 << "\", " << m.vectpair1 << ", " << m.vect << ", " << m.vectpair2 << ", " << m.vectpair3 << " )";
 752         break;
 753     case MockCliEvent::EVENT_PRINT_HELP_SHOW_KINDS:
 754         out << "printHelpShowKinds( " << m.vect << " )";
 755         break;
 756     case MockCliEvent::EVENT_CHOOSE_CHANGESET:
 757         out << "chooseChangeset( " << m.changesets << " )";
 758         break;
 759     case MockCliEvent::RETURN_CHOOSE_CHANGESET:
 760         out << "returnChooseChangeset( " << m.integer << " )";
 761         break;
 762     case MockCliEvent::EVENT_READ_LINE:
 763         out << "readLine( \"" << m.str1 << "\" )";
 764         break;
 765     case MockCliEvent::RETURN_READ_LINE:
 766         out << "returnReadLine( \"" << m.strbool.first << "\", " <<  m.strbool.second << " )";
 767         break;
 768     case MockCliEvent::EVENT_PRINT_ATTRIBUTES:
 769         out << "printAttributes( " << m.attrs << ", " << m.integer << " )";
 770         break;
 771     case MockCliEvent::EVENT_PRINT_ATTRIBUTE:
 772         out << "printAttribute( " << *(m.attr) << ", " << m.integer << " )";
 773         break;
 774     case MockCliEvent::EVENT_PRINT_ATTRIBUTES_WITH_ORIGIN:
 775         out << "printAttributesWithOrigin( " << m.attrsorig << ", " << m.integer << " )";
 776         break;
 777     case MockCliEvent::EVENT_PRINT_ATTRIBUTE_WITH_ORIGIN:
 778         out << "printAttributeWithOrigin( " << *(m.attr) << ", " << m.ident << ", " << m.integer << " )";
 779         break;
 780     case MockCliEvent::EVENT_PRINT_OBJECTS:
 781         out << "printObjects( " << m.objects << ", " << m.integer << " )";
 782         break;
 783     case MockCliEvent::EVENT_PRINT_OBJECT:
 784         out << "printObject( " << *(m.object) << ", " << m.integer << " )";
 785         break;
 786     case MockCliEvent::EVENT_PRINT_END:
 787         out << "printEnd( " << m.integer << " )";
 788         break;
 789     case MockCliEvent::EVENT_PRINT_REVISIONS:
 790         out << "printRevisions( " << m.revisions << " )";
 791         break;
 792     case MockCliEvent::EVENT_PRINT_DIFF:
 793         out << "printDiff( " << m.diff << " )";
 794         break;
 795     case MockCliEvent::EVENT_ADD_COMMAND_COMPLETION:
 796         out << "addCommandCompletion( \"" << m.str1 << "\" )";
 797         break;
 798     case MockCliEvent::EVENT_INVALID:
 799         out << "[no event]";
 800         break;
 801     }
 802     return out;
 803 }