test.cpp

/*
    $Id: test_8cpp-source.html,v 1.1 2004/10/05 21:12:03 mentat Exp $

    GNU Messenger - The secure instant messenger

    Copyright (C) 2003 Jesse Lovelace <jllovela@eos.ncsu.edu>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "gm/gm.h"
#include "gm/xml.h"
#include "gm/xml_manager.h"
#include "gm/contact_manager.h"
#include "gm/settings_manager.h"
#include <sstream>
#include <iostream>
#include <string>

using namespace std;
using namespace GNUMessenger;

int failure;
int success;

#define VERIFY(a,b) { \
    if ((a)==(b)) \
        { cout << "Passed.." << endl; success++; } \
    else \
        { cout << "Failed at " << __FILE__ << ":" << __LINE__ << endl; failure++; } \
}


#define VERIFY_THROW(a) { bool didThrow = false; \
    try { a; } \
    catch(GNUMessenger::Exception &e) \
        { \
            didThrow = true; \
            cout << e.what() << endl; \
        } \
        if (didThrow)   \
        { cout << "Passed.." << endl; success++; } \
    else \
        { cout << "Failed at " << __FILE__ << ":" << __LINE__ << endl; failure++; } \
}

#define VERIFY_NO_THROW(a) { bool didThrow = false; \
    try { a; } \
    catch(GNUMessenger::Exception &e) \
        { \
            didThrow = true; \
            cout << e.what() << endl; \
        } \
        if (!didThrow)   \
        { cout << "Passed.." << endl; success++; } \
    else \
        { cout << "Failed at " << __FILE__ << ":" << __LINE__ << endl; failure++; } \
}

int testFolder()
{

    XMLNode myXML;
    myXML << "<folder></folder>";

    Folder myFolder;
    Folder myFolder1("<folder><contact name=\"john\"/></folder>");
    Folder myFolder2(myXML);

    VERIFY(myFolder2.isOK(), true);

    cout << "Successes: " << success << endl;
    cout << "Failures: " << failure << endl;

    return 0;
}

int testChild()
{
    cout << "------begin Testing XML Childs ------\n";
    XMLNode n;

    n.setName("hej");
    n.addChild("aloha");
    n.child("aloha").setProperty("hej","hello");

    VERIFY(n.numChildren("aloha"),1);
    VERIFY(n.child("aloha").property("hej"),"hello");

    VERIFY(n.child("notvalid").name(), "");
    VERIFY(n.child("doesntexist").child("notthisoneeither").name(), "");
    VERIFY(n.child("doesntexist").property("notthisoneeither"),"");

    const XMLNode cn;

    VERIFY_THROW(cn.child("notvalid").name());
    
    return 0;
}

int testProperty()
{
    cout << "------begin Testing XML Properties ------\n";
    XMLNode n;

    n.setName("hej");

    n.setProperty("test","yes");

    VERIFY(n.property("test"),"yes");
    VERIFY(n["test"],"yes");

    VERIFY(n.property("nonexisting"),"");
    
    return 0;
}

int testParsing()
{
    cout << "------begin Testing XML Parsing ------\n";

    XMLParser e("   <messages>"
               "<message sender=\"test\" subject=\"-\">"
               "foo bla bla"
               "</message>"
               "</messages> ");
    XMLNode bla;
    XMLNode n;
    XMLNode *blargh= new XMLNode();

    *blargh = e.get_root();
    bla=*blargh;
    n=*blargh;

    delete blargh;
    blargh=0;

    n.setProperty("foo","bar");

    VERIFY(bla.property("foo"),"bar");
    VERIFY(n.name(),"messages");
    bla.setName("hej");
    VERIFY(n.name(),"hej");

    //cout << n << endl;
    //cout << "------end Testing XML Parsing ------\n";
    
    return 0;
}

int testParsing2()
{
    cout << "------begin Testing invalid XML Parsing ------\n";

    auto_ptr<XMLParser> e;
    VERIFY_THROW(e.reset(new XMLParser("   <messages"
               "<message sender=\"test\" subject=\"-\">"
               "foo bla bla"
               "<message>"
               "</messages> ")));

    XMLNode bla;
    XMLNode n;
    XMLNode *blargh= new XMLNode();

   // *blargh = e->get_root();
    bla=*blargh;
    n=*blargh;
    delete blargh;
    blargh=0;

    n.setProperty("foo","bar");
    VERIFY(bla.property("foo"),"bar");

    //cout << n << endl;
    bla.setName("hej");
    VERIFY(n.name(),"hej");

    //cout << "------end Testing invalid XML Parsing ------\n";
    return 0;
}

int testConst()
{
    cout << "------begin Testing constant nodes ------\n";
    XMLNode a,c;
    a.setName("henrik");
    a.setProperty("foo","var");

    const XMLNode b(a);
    c=b;
    c.setName("nisse");
    //cout << a << endl;

    //VERIFY(a.name(),"henrik");
   // VERIFY(b.name(),"henrik");

    VERIFY(b["foo"],"var");

    VERIFY(c.name(),"nisse");
    VERIFY(c["foo"],"var");
    
    return 0;
}


int testFoo()
{
    // I'm not sure what this test does :) -jll
    string str="<foo>\n<bla pro='ba' pro2='ff' >h\n;&amp;e\nj<bar hej='foo' > ni&amp;ise </bar> </bla>\n</foo>\n"; 
    for (int i=0; i<20; i++)
    {
        XMLNode n;
        n << str;
        //cout << "Data: '" <<  n.child("bla").data() << "'\n";
        str = n;
        //cout << "----------------\n" << str <<  "----------------\n" ;
    }
    return 0;
}

int jesseTest()
{
    // this test checks for a formatting bug that arose when
    // the expat code saved whitespaces
    cout << "------begin Testing tortcher test \"jesse\" ------\n";
    string teststr("<config>\n<people>\n</people>\n<animals>\n</animals></config>");
    
    for (int i = 0; i < 30; i++)
    {
        stringstream name;
        name << "jones" << i; 
        XMLNode n;
        n << teststr;
        
        if (i % 5 == 0)
            n.child("config").child("animals").addChild(name.str());
        
        n.child("config").child("people").addChild(name.str());
        teststr = string(n);
    }
    XMLNode final;
    
    final << teststr;

    return 0;
}

int XText1()
{
    cout << "------begin Testing XML Parsing 2 ------\n";
    string teststr("<config dudes=\"1\">\n<people>\n</people>\n<animals>\n</animals></config>");
    
    XMLNode n;
    VERIFY_NO_THROW(n << teststr);

    return 0;
}

int testMove()
{
    cout << "------begin Testing Move ------\n";
    XMLNode node;
    VERIFY_NO_THROW(node << "<node><james/><jim/><tom/></node>");

    XMLNode test;

    // this should move tom to the front
    VERIFY_NO_THROW(test << "<node><tom/><james/><jim/></node>");

    VERIFY_NO_THROW(node.moveChild(2, 0));

    VERIFY(static_cast<string>(node), static_cast<string>(test));

    // this should move james to the back
    VERIFY_NO_THROW(test << "<node><tom/><jim/><james/></node>");
    
    VERIFY_NO_THROW(node.moveChild(1, 3));

    VERIFY(static_cast<string>(node), static_cast<string>(test));

    return 0;
}

int contactTest1()
{

    cout << "------begin Testing Contacts ------\n";
    Contact d;

    Contact c;
    c.addProtocol("kit");
    c.setServerId("kit", "henrik");
    
    VERIFY (c.getServerId("kit"),"henrik");
   
    c.setName("nisse");

    VERIFY (c.name(),"nisse");
    VERIFY (c.getStatus("kit"),Contact::Offline);

    c.setStatus("kit", Contact::Online);
    VERIFY (c.getStatus("kit"),Contact::Online);

    VERIFY (c.getProtocol(),"kit");
    
    d=c;

    VERIFY (d.getProtocol(),"kit");
    VERIFY (d.getServerId("kit"),"henrik");
    VERIFY (d.name(),"nisse");

    VERIFY ((c==d),true);

    return 0;
}

int contactTest2()
{
    cout << "------begin Testing Contacts 2 ------\n";
    Contact c;

    //VERIFY (c.getProtocol(),"");
    VERIFY_THROW (c.getServerId("toc"));
    VERIFY (c.name(),"");
    return 0;
}

int contactTest3()
{
    cout << "------begin Testing Contacts 3 ------\n";
    // construct
    Contact joe;
    VERIFY(joe.isOK(), true);

    // setName
    joe.setName("joe");
    VERIFY(joe.name(), "joe");

    // setStatus
    VERIFY_THROW(joe.setStatus("toc", Contact::Online));
    VERIFY_THROW(joe.getStatus("toc"));

    // setStatus
    joe.addProtocol("toc");
    joe.setStatus("toc", Contact::Online);
    VERIFY(joe.getStatus("toc"), Contact::Online);

    // Assignment
    Contact jim(joe);

    VERIFY(joe, jim);

    // Assignment 2
    jim.setName("tim");
    joe = jim;
    VERIFY(joe, jim);

    return 0;

}

int contactTest4()
{
    cout << "------begin Testing Contacts 4 ------\n";
    XMLNode node;
    node <<
        "<config>"
        "<contacts>"
            "<folder>"
                "<contact name = \"jim\">"
                    "<info name=\"joe\">"
                        "<part>"
                        "<diode/>"
                        "</part>"
                    "</info>"
                "</contact>"
            "</folder>"
        "</contacts>"
        "</config>";

    XMLNode node2(node.child("contacts").child("folder"));

    node2.setProperty("name", "sam");

    ContactManager mng(node);

    cout << string(node) << endl;

    try {
        XMLNode temp2(mng.getContact("jim"));
        temp2.child("info").setProperty("name", "tim");
        cout << string(temp2) << endl;
        VERIFY(node.child("contacts").child("folder").
            child("contact").child("info").property("name"), "tim");
    }
    catch(Exception &e)
    {
        cout << e.what() << endl; 
        return 1;
    }

    cout << string(node) << endl;

    

    return 0;


}

int xml_manager_test1()
{
    cout << "------begin Testing XMLManager 1 ------\n";

    XMLManager myManager;
    VBuffer passw("dork");
    myManager.createNew("test", passw);
    myManager.logout();

    // test to see if the file was created
    VERIFY(XMLManager::exists("test"), true);

    // test login
    VERIFY(myManager.login("test", passw), true);

    // test commit
    VERIFY(myManager.commit(), true);

    // test profile saving
    myManager.settings().setProfile("This is me!");

    VERIFY(myManager.settings().getProfile(), "This is me!");

    // test public key saving
    myManager.settings().setPublicKey("ABCDEFG");

    VERIFY(myManager.settings().getPublicKey(), "ABCDEFG");

    // test away message saving
    myManager.settings().setAwayMessage("out", "not in");

    VERIFY(myManager.settings().getAwayMessage("out"), "not in");

    // test network object storage
    XMLNode mynet, myTestNet;

    mynet << "<toc><server port=\"99\" host=\"myserv.com\"/></toc>";

    myManager.settings().setNet(mynet);

    myManager.settings().getNet("toc", myTestNet);

    // I could do a c-style cast here but i'm trying to break myself
    // of that habit
    VERIFY(static_cast<string>(mynet), static_cast<string>(myTestNet));

    myManager.commit();

    // test logout
    VERIFY(myManager.logout(), true);

    return 0;
}

int net_conf_test1()
{
    cout << "------begin Testing NetConf ------\n";
    XMLNode conf;
    conf << "<toc><server port=\"445\" host=\"toc.com\"/>"
        "<loginserver host=\"login.toc.com\" port=\"111\"/></toc>";

    NetConf myNet(conf);

    VERIFY(myNet.getProtocol(), "toc");
    VERIFY(myNet.getServer(), "toc.com");
    VERIFY(myNet.getLoginServer(), "login.toc.com");
    VERIFY(myNet.getLoginPort(), 111);
    VERIFY(myNet.getServerPort(), 445);

    VBuffer mypass("mypass");
    myNet.setPassword(mypass);

    VERIFY(mypass, myNet.getPassword());

    // oh mad skilz, did you say named constructor?
    NetConf myinfo(NetConf().
        setProtocol("toc").
        setServer("toc.aim.com").
        setServerPort(200).
        setLogin("m3ntat").
        setPassword(string("dude")));

    return 0;

}

int main()
{
    gLogger = new Log();

    success = 0;
    failure = 0;

   try {
        testFolder();
        XText1();
        testProperty();
        testChild();
        testParsing();
        testParsing2();
        testConst();
        testFoo();  
        jesseTest();
        testMove();
     
        contactTest1();
        contactTest2();
        contactTest3();
        contactTest4();

        xml_manager_test1();
        net_conf_test1();
    }
    catch(XMLNode::InvalidChild& e)
    {
        cout << "Exception(InvalidChild): " << e.what() << endl;
        return failure;
    }
    catch(XMLNode::ParseFailure& e)
    {
        cout << "Exception(ParseFailure): " << e.what() << endl;
        return failure;
    }
    catch(...)
    {
        cout << "Unkown exception!" << endl;
        return failure;
    }

    delete gLogger;
    gLogger = 0;

    cout << "Successes: " << success << endl;
    cout << "Failures: " << failure << endl;

    return failure;
    
}

---