You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1162 lines
48 KiB
1162 lines
48 KiB
/***************************************************************************
|
|
* This file is part of the KDE project
|
|
* copyright (C) 2006 by Bernd Steindorff (bernd@itii.de)
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
* You should have received a copy of the GNU Library General Public License
|
|
* along with this program; see the file COPYING. If not, write to
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
***************************************************************************/
|
|
|
|
#include "xmlhandlertests2.h"
|
|
#include "testaction.h"
|
|
#include "komacrotestbase.h"
|
|
|
|
#include "../lib/action.h"
|
|
#include "../lib/manager.h"
|
|
#include "../lib/macro.h"
|
|
#include "../lib/variable.h"
|
|
#include "../lib/macroitem.h"
|
|
|
|
#include <ostream>
|
|
#include <cfloat>
|
|
|
|
#include <tqdom.h>
|
|
|
|
#include <kdebug.h>
|
|
#include <tdeunittest/runner.h>
|
|
#include <kxmlguiclient.h>
|
|
|
|
using namespace KUnitTest;
|
|
using namespace KoMacroTest;
|
|
|
|
namespace KoMacroTest {
|
|
|
|
/**
|
|
* Register KoMacroTest::CommonTests as TestSuite.
|
|
*/
|
|
KUNITTEST_SUITE("KoMacroTestSuite")
|
|
KUNITTEST_REGISTER_TESTER(XMLHandlerTests2);
|
|
|
|
class XMLHandlerTests2::Private
|
|
{
|
|
public:
|
|
/**
|
|
* An KXMLGUIClient instance created on @a setUp() and
|
|
* passed to the @a KoMacro::Manager to bridge to the
|
|
* app-functionality.
|
|
*/
|
|
KXMLGUIClient* xmlguiclient;
|
|
|
|
/**
|
|
* @a Macro instance as a container for the macroitems;
|
|
*/
|
|
KSharedPtr<KoMacro::Macro> macro; // container for manually created items
|
|
KSharedPtr<KoMacro::Macro> macro2; // container for parsen items
|
|
KSharedPtr<KoMacro::Macro> macro3; // container for parsen items after back-converting by toXML() and again parseXML()
|
|
|
|
/**
|
|
* An @a TestObject instance used internaly to test
|
|
* handling and communication with from TQObject
|
|
* inheritated instances.
|
|
*/
|
|
KSharedPtr<KoMacro::Action> testaction;
|
|
KSharedPtr<KoMacro::Action> action2; // action of the parsen macro2
|
|
KSharedPtr<KoMacro::Action> action3; // action of the parsen macro3
|
|
KSharedPtr<KoMacro::Action> testaction_2; // for test12
|
|
KSharedPtr<KoMacro::Action> action2_2; // action of the parsen macro2, for test12
|
|
KSharedPtr<KoMacro::Action> action3_2; // action of the parsen macro3, for test12
|
|
|
|
/**
|
|
* Represents a @a TQValuList of @a MacroItem which are parsen in the
|
|
* correspondig @a Macro .
|
|
*/
|
|
TQValueList<KSharedPtr<KoMacro::MacroItem > > macroitems2; // items of macro2
|
|
TQValueList<KSharedPtr<KoMacro::MacroItem > > macroitems3; // items of macro3
|
|
|
|
/**
|
|
* @a MacroItem instances which ist fillen manually from the given XML
|
|
* and parsen by the @a XMLHandler over the XML.
|
|
*/
|
|
KSharedPtr<KoMacro::MacroItem> macroitem; // created manually from XML
|
|
KSharedPtr<KoMacro::MacroItem> macroitem2; // parsen from XML in macro2
|
|
KSharedPtr<KoMacro::MacroItem> macroitem3; // parsen from XML in macro3
|
|
KSharedPtr<KoMacro::MacroItem> macroitem_2; // created manually from XML, for test12
|
|
KSharedPtr<KoMacro::MacroItem> macroitem2_2;// parsen from XML in macro2, for test12
|
|
KSharedPtr<KoMacro::MacroItem> macroitem3_2;// parsen from XML in macro3, for test12
|
|
|
|
Private()
|
|
: xmlguiclient(0)
|
|
, testaction(0)
|
|
{
|
|
}
|
|
};
|
|
}
|
|
|
|
XMLHandlerTests2::XMLHandlerTests2()
|
|
: KUnitTest::SlotTester()
|
|
, d( new Private() ) // create the private d-pointer instance.
|
|
{
|
|
}
|
|
|
|
XMLHandlerTests2::~XMLHandlerTests2()
|
|
{
|
|
delete d->xmlguiclient;
|
|
delete d;
|
|
}
|
|
|
|
|
|
void XMLHandlerTests2::setUp()
|
|
{
|
|
d->xmlguiclient = new KXMLGUIClient();
|
|
|
|
//Singelton more or less ...
|
|
if (::KoMacro::Manager::self() == 0) {
|
|
::KoMacro::Manager::init( d->xmlguiclient );
|
|
}
|
|
|
|
d->macro = KoMacro::Manager::self()->createMacro("testMacro");
|
|
d->macro2 = KoMacro::Manager::self()->createMacro("testMacro");
|
|
d->macro3 = KoMacro::Manager::self()->createMacro("testMacro");
|
|
|
|
d->testaction = new TestAction();
|
|
d->testaction_2 = new TestAction();
|
|
::KoMacro::Manager::self()->publishAction(d->testaction);
|
|
::KoMacro::Manager::self()->publishAction(d->testaction_2);
|
|
}
|
|
|
|
void XMLHandlerTests2::tearDown()
|
|
{
|
|
delete d->xmlguiclient;
|
|
}
|
|
|
|
/**
|
|
* Test the @a KoMacro::XMLHandler parseXML() and toXML()-function.
|
|
*/
|
|
void XMLHandlerTests2::testParseAndToXML()
|
|
{
|
|
kdDebug()<<"===================== testParseAndToXML2() ======================" << endl;
|
|
|
|
// 1.Test - Correct DomElement.
|
|
testCorrectDomElement();
|
|
// 2.Test - XML-document with bad root element.
|
|
testBadRoot();
|
|
// 3.Test - XML-document with a missing Variable.
|
|
testMissingVariable();
|
|
// 4.Test - One more Variable in XML-Document.
|
|
testMoreVariables();
|
|
// 5.Test - XML-document with wrong macro-xmlversion.
|
|
testWrongVersion();
|
|
// 6.Test - XML-document if it has a wrong structure like wrong parathesis
|
|
// or missing end tag.
|
|
testWrongXMLStruct();
|
|
// 7.Test-XML-document with maximum field-size.
|
|
testMaxNum();
|
|
// 8.Test-XML-document with maximum+1 field-size.
|
|
testMaxNum2();
|
|
// 9.Test-XML-document with minimum field-size.
|
|
testMinNum();
|
|
// 10.Test-XML-document with minimum-1 field-size.
|
|
testMinNum2();
|
|
// 11.Test - With a to big number.
|
|
testBigNumber();
|
|
// 12.Test - With two MacroItems.
|
|
testTwoMacroItems();
|
|
}
|
|
|
|
|
|
/***************************************************************************
|
|
* Begin of Sub-methos of testParseXML().
|
|
***************************************************************************/
|
|
// 1.Test - Correct DomElement.
|
|
void XMLHandlerTests2::testCorrectDomElement()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" >0</variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" >0.6</variable>"
|
|
"</item>"
|
|
"</macro>");
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(0));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(0.6));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *d->macroitems2.constBegin();
|
|
d->action2 = d->macroitem2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem2->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")), true);
|
|
}
|
|
}
|
|
// Change varint and the belonging Variable in the parsen macro2test
|
|
// and test it in the macro3 below
|
|
varint->setVariant(117);
|
|
d->macroitem2->variable("testint")->setVariant(117);
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *d->macroitems3.constBegin();
|
|
d->action3 = d->macroitem3->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem3->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")), true);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 2.Test - XML-document with bad root element.
|
|
void XMLHandlerTests2::testBadRoot()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<maro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" >0</variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" >0.6</variable>"
|
|
"</item>"
|
|
"</maro>");
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(0));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(0.6));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_XASSERT(d->macro2->parseXML(elem),true);
|
|
}
|
|
|
|
// 3.Test - XML-document with a missing Variable.
|
|
void XMLHandlerTests2::testMissingVariable()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" >0</variable>"
|
|
"<variable name=\"testdouble\" >0.6</variable>"
|
|
"</item>"
|
|
"</macro>");
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(0));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(0.6));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *d->macroitems2.constBegin();
|
|
d->action2 = d->macroitem2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)3);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")), true);
|
|
}
|
|
}
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *d->macroitems3.constBegin();
|
|
d->action3 = d->macroitem3->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)3);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")), true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 4.Test - One more Variable in XML-Document.
|
|
void XMLHandlerTests2::testMoreVariables()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" >0</variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" >0.6</variable>"
|
|
"<variable name=\"testbla\" >somethingwrong</variable>"
|
|
"</item>"
|
|
"</macro>");
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(0));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(0.6));
|
|
KSharedPtr<KoMacro::Variable> varbla = d->macroitem->addVariable("testbla","somethingwrong");
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *d->macroitems2.constBegin();
|
|
d->action2 = d->macroitem2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)5);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem2->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbla, d->macroitem2->variable("testbla")), true);
|
|
}
|
|
}
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *d->macroitems3.constBegin();
|
|
d->action3 = d->macroitem3->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)5);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem3->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbla, d->macroitem3->variable("testbla")), true);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 5.Test - XML-document with wrong macro-xmlversion.
|
|
void XMLHandlerTests2::testWrongVersion()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<maro xmlversion=\"2\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" >0</variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" >0.6</variable>"
|
|
"</item>"
|
|
"</maro>");
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(0));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(0.6));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_XASSERT(d->macro2->parseXML(elem),true);
|
|
}
|
|
|
|
|
|
// 6.Test - XML-document if it has a wrong structure like wrong parathesis
|
|
// or missing end tag.
|
|
void XMLHandlerTests2::testWrongXMLStruct()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"maro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" >0</variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" >0.6</variable>"
|
|
"</item>"
|
|
"</maro>");
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(0));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(0.6));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_XASSERT(d->macro2->parseXML(elem),true);
|
|
}
|
|
|
|
// 7.Test-XML-document with maximum field-size.
|
|
void XMLHandlerTests2::testMaxNum()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" > %1 </variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" > %2 </variable>"
|
|
"</item>"
|
|
"</macro>").arg(INT_MAX).arg(DBL_MAX);
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(INT_MAX));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(DBL_MAX));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *d->macroitems2.constBegin();
|
|
d->action2 = d->macroitem2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem2->variable("testbool")), true);
|
|
// KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")), true);
|
|
}
|
|
}
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *d->macroitems3.constBegin();
|
|
d->action3 = d->macroitem3->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem3->variable("testbool")), true);
|
|
// KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")),true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 8.Test-XML-document with maximum+1 field-size.
|
|
void XMLHandlerTests2::testMaxNum2()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" > %1 </variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" > %2 </variable>"
|
|
"</item>"
|
|
"</macro>").arg(INT_MAX+1).arg(DBL_MAX+1);
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(INT_MAX+1));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(DBL_MAX+1));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *d->macroitems2.constBegin();
|
|
d->action2 = d->macroitem2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem2->variable("testbool")), true);
|
|
// KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")),true);
|
|
}
|
|
}
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *d->macroitems3.constBegin();
|
|
d->action3 = d->macroitem3->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem3->variable("testbool")), true);
|
|
// KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")),true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 9.Test-XML-document with minimum field-size.
|
|
void XMLHandlerTests2::testMinNum()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" > %1 </variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" > %2 </variable>"
|
|
"</item>"
|
|
"</macro>").arg(INT_MIN).arg(DBL_MIN);
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(INT_MIN));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(DBL_MIN));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *d->macroitems2.constBegin();
|
|
d->action2 = d->macroitem2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem2->variable("testbool")), true);
|
|
// KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")),true);
|
|
}
|
|
}
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *d->macroitems3.constBegin();
|
|
d->action3 = d->macroitem3->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem3->variable("testbool")), true);
|
|
// KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")),true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 10.Test-XML-document with minimum+1 field-size.
|
|
void XMLHandlerTests2::testMinNum2()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" > %1 </variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" > %2 </variable>"
|
|
"</item>"
|
|
"</macro>").arg(INT_MIN-1).arg(DBL_MIN-1);
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(INT_MIN-1));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(DBL_MIN-1));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *d->macroitems2.constBegin();
|
|
d->action2 = d->macroitem2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem2->variable("testbool")), true);
|
|
// KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")),true);
|
|
}
|
|
}
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *d->macroitems3.constBegin();
|
|
d->action3 = d->macroitem3->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem3->variable("testbool")), true);
|
|
// KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")),true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 11.Test - With a to big number.
|
|
void XMLHandlerTests2::testBigNumber()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" >0123456789012345678901234567890123456789</variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" >0.6</variable>"
|
|
"</item>"
|
|
"</macro>");
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
//TODO //KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(0123456789012345678901234567890123456789));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(0.6));
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *d->macroitems2.constBegin();
|
|
d->action2 = d->macroitem2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")), true);
|
|
//KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem2->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")), true);
|
|
}
|
|
}
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)1);
|
|
|
|
{
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *d->macroitems3.constBegin();
|
|
d->action3 = d->macroitem3->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)4);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")), true);
|
|
//KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem3->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")), true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 12.Test - With two MacroItems.
|
|
void XMLHandlerTests2::testTwoMacroItems()
|
|
{
|
|
// Clear macroitems in the macros.
|
|
d->macro->clearItems();
|
|
d->macro2->clearItems();
|
|
d->macro3->clearItems();
|
|
|
|
// Part 1: From XML to a Macro.
|
|
// Test-XML-document with normal allocated variables.
|
|
const TQString xml = TQString("<!DOCTYPE macros>"
|
|
"<macro xmlversion=\"1\">"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >test_string</variable>"
|
|
"<variable name=\"testint\" >0</variable>"
|
|
"<variable name=\"testbool\" >true</variable>"
|
|
"<variable name=\"testdouble\" >0.6</variable>"
|
|
"<variable name=\"testbla\" >somethingwrong</variable>"
|
|
"</item>"
|
|
"<item action=\"testaction\" >"
|
|
"<variable name=\"teststring\" >testString2</variable>"
|
|
"<variable name=\"testint\" >4</variable>"
|
|
"<variable name=\"testbool\" >false</variable>"
|
|
"<variable name=\"testdouble\" >0.7</variable>"
|
|
"<variable name=\"testbla\" >somethingwrong2</variable>"
|
|
"</item>"
|
|
"</macro>");
|
|
// Set the XML-document with the above string.
|
|
TQDomDocument doomdocument;
|
|
doomdocument.setContent(xml);
|
|
const TQDomElement elem = doomdocument.documentElement();
|
|
|
|
// Create a MacroItem with the TestAction for macro2 and add it to macro.
|
|
d->macroitem = new KoMacro::MacroItem();
|
|
d->macroitem_2 = new KoMacro::MacroItem();
|
|
d->macro->addItem(d->macroitem);
|
|
d->macro->addItem(d->macroitem_2);
|
|
|
|
d->macroitem->setAction(d->testaction);
|
|
d->macroitem_2->setAction(d->testaction_2);
|
|
|
|
// Push the Variables into the macroitem.
|
|
KSharedPtr<KoMacro::Variable> varstring = d->macroitem->addVariable("teststring",TQVariant("test_string"));
|
|
KSharedPtr<KoMacro::Variable> varint = d->macroitem->addVariable("testint",TQVariant(0));
|
|
KSharedPtr<KoMacro::Variable> varbool = d->macroitem->addVariable("testbool",TQVariant(true));
|
|
KSharedPtr<KoMacro::Variable> vardouble = d->macroitem->addVariable("testdouble",TQVariant(0.6));
|
|
KSharedPtr<KoMacro::Variable> varbla = d->macroitem->addVariable("testbla","somethingwrong");
|
|
|
|
// Push the Variables into the macroitem4.
|
|
KSharedPtr<KoMacro::Variable> varstring_2 = d->macroitem_2->addVariable("teststring",TQVariant("testString2"));
|
|
KSharedPtr<KoMacro::Variable> varint_2 = d->macroitem_2->addVariable("testint",TQVariant(4));
|
|
KSharedPtr<KoMacro::Variable> varbool_2 = d->macroitem_2->addVariable("testbool",TQVariant(false));
|
|
KSharedPtr<KoMacro::Variable> vardouble_2 = d->macroitem_2->addVariable("testdouble",TQVariant(0.7));
|
|
KSharedPtr<KoMacro::Variable> varbla_2 = d->macroitem_2->addVariable("testbla","somethingwrong2");
|
|
|
|
// Is our XML parseable into a 2. Macro by calling parseXML()?
|
|
KOMACROTEST_ASSERT(d->macro2->parseXML(elem),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems2 = d->macro2->items();
|
|
// 1a.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems2.size(),(sizetypelist)2);
|
|
|
|
{
|
|
TQValueList<KSharedPtr<KoMacro::MacroItem > >::ConstIterator mit2(d->macroitems2.constBegin());
|
|
// 2a.comparison - Test if the Action is correct?
|
|
d->macroitem2 = *mit2;
|
|
mit2++;
|
|
d->macroitem2_2 = *mit2;
|
|
d->action2 = d->macroitem2->action();
|
|
d->action2_2 = d->macroitem2_2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action2),true);
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction_2,d->action2_2),true);
|
|
|
|
// 3a.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem2->variables().size(),(sizetypemap)5);
|
|
KOMACROTEST_ASSERT(d->macroitem2_2->variables().size(),(sizetypemap)5);
|
|
{
|
|
// 4a.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem2->variable("teststring")),true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem2->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem2->variable("testdouble")),true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbla, d->macroitem2->variable("testbla")),true);
|
|
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring_2,d->macroitem2_2->variable("teststring")),true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint_2, d->macroitem2_2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool_2, d->macroitem2_2->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble_2,d->macroitem2_2->variable("testdouble")),true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbla_2, d->macroitem2_2->variable("testbla")),true);
|
|
}
|
|
}
|
|
|
|
// Now convert the parsen macro2 back to a TQDomElement and again into macro3 for a better comparison.
|
|
const TQDomElement elem2 = d->macro2->toXML();
|
|
KOMACROTEST_ASSERT(d->macro3->parseXML(elem2),true);
|
|
|
|
// Go down to the MacroItem of macro2.
|
|
d->macroitems3 = d->macro3->items();
|
|
// 1b.comparison - Test if the MacroItems have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitems3.size(),(sizetypelist)2);
|
|
|
|
{
|
|
TQValueList<KSharedPtr<KoMacro::MacroItem > >::ConstIterator mit3(d->macroitems3.constBegin());
|
|
// 2b.comparison - Test if the Action is correct?
|
|
d->macroitem3 = *mit3;
|
|
mit3++;
|
|
d->macroitem3_2 = *mit3;
|
|
d->action3 = d->macroitem3->action();
|
|
d->action3_2 = d->macroitem3_2->action();
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3),true);
|
|
KOMACROTEST_ASSERT(assertActionsEqual(d->testaction,d->action3_2),true);
|
|
|
|
// 3b.comparison - Test if the Variables have the correct number?
|
|
KOMACROTEST_ASSERT(d->macroitem3->variables().size(),(sizetypemap)5);
|
|
KOMACROTEST_ASSERT(d->macroitem3_2->variables().size(),(sizetypemap)5);
|
|
{
|
|
// 4b.comparison - Test if the Variables are equal.
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring, d->macroitem3->variable("teststring")),true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint, d->macroitem3->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool, d->macroitem3->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble, d->macroitem3->variable("testdouble")),true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbla, d->macroitem3->variable("testbla")),true);
|
|
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varstring_2,d->macroitem3_2->variable("teststring")),true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varint_2, d->macroitem3_2->variable("testint")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbool_2, d->macroitem3_2->variable("testbool")), true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(vardouble_2,d->macroitem3_2->variable("testdouble")),true);
|
|
KOMACROTEST_ASSERT(assertVariablesEqual(varbla_2, d->macroitem3_2->variable("testbla")),true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
* End of Sub-methos of testParseAndToXML2().
|
|
***************************************************************************/
|
|
|
|
bool XMLHandlerTests2::assertActionsEqual(KSharedPtr<KoMacro::Action> action,
|
|
KSharedPtr<KoMacro::Action> action2)
|
|
{
|
|
return action->name() == action2->name();
|
|
}
|
|
|
|
bool XMLHandlerTests2::assertVariablesEqual(KSharedPtr<KoMacro::Variable> var,
|
|
KSharedPtr<KoMacro::Variable> var2)
|
|
{
|
|
if ( var->variant() != var2->variant() ) kdDebug() << "Variable1: " << var->variant() << " and Variable2: " << var2->variant() << endl;
|
|
return var->variant() == var2->variant();
|
|
}
|
|
|
|
#include "xmlhandlertests2.moc"
|