Client::Client(const JID& jid, const String& password) :

IQRouter(this), jid_(jid), password_(password), session_(0) {

tlsLayerFactory_ = new PlatformTLSLayerFactory();

}

Client::~Client() {

delete session_;

delete tlsLayerFactory_;

}

void Client::connect() {

case Session::ConnectionReadError:

clientError = ClientError(ClientError::ConnectionReadError);

break;

case Session::XMLError:

clientError = ClientError(ClientError::XMLError);

break;

#include "Swiften/Queries/IQRouter.h"

#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"

#include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"

namespace Swift {

class TLSLayerFactory;

class ConnectionFactory;

class Session;

void setCertificate(const String& certificate);

void disconnect();

virtual void sendMessage(boost::shared_ptr<Message>);

virtual void sendPresence(boost::shared_ptr<Presence>);

boost::signal<void (const String&)> onDataRead;

boost::signal<void (const String&)> onDataWritten;

private:

void handleElement(boost::shared_ptr<Element>);

void handleSessionError(Session::SessionError error);

void handleNeedCredentials();

void handleDataRead(const ByteArray&);

void handleDataWritten(const ByteArray&);

JID jid_;

IDGenerator idGenerator_;

ConnectionFactory* connectionFactory_;

TLSLayerFactory* tlsLayerFactory_;

FullPayloadSerializerCollection payloadSerializers_;

Session* session_;

String certificate_;

}

#endif

DomainNameResolveError,

ConnectionError,

ConnectionReadError,

XMLError,

AuthenticationFailedError,

NoSupportedAuthMechanismsError,

void Session::start() {

assert(state_ == Initial);

state_ = Connecting;

connection_->onConnected.connect(boost::bind(&Session::handleConnected, this));

connection_->onError.connect(boost::bind(&Session::handleConnectionError, this, _1));

}

void Session::stop() {

case Connection::ReadError:

setError(ConnectionReadError);

break;

case Connection::ConnectionError:

setError(ConnectionError);

break;

DomainNameResolveError,

ConnectionError,

ConnectionReadError,

XMLError,

AuthenticationFailedError,

NoSupportedAuthMechanismsError,

CPPUNIT_TEST(testSessionStart);

CPPUNIT_TEST(testSessionStart_Error);

CPPUNIT_TEST(testSessionStart_AfterResourceBind);

CPPUNIT_TEST(testReceiveElementAfterSessionStarted);

CPPUNIT_TEST_SUITE_END();

public:

}

void tearDown() {

delete eventLoop_;

}

CPPUNIT_ASSERT_EQUAL(Session::Negotiating, session->getState());

}

std::auto_ptr<MockSession> session(createSession("me@foo.com/Bar"));

session->start();

getMockServer()->expectStreamStart();

CPPUNIT_ASSERT_EQUAL(Session::Error, session->getState());

CPPUNIT_ASSERT_EQUAL(Session::AuthenticationFailedError, session->getError());

std::auto_ptr<MockSession> session(createSession("me@foo.com/Bar"));

session->start();

getMockServer()->expectStreamStart();

CPPUNIT_ASSERT_EQUAL(Session::Error, session->getState());

CPPUNIT_ASSERT_EQUAL(Session::NoSupportedAuthMechanismsError, session->getError());

void testResourceBind() {

std::auto_ptr<MockSession> session(createSession("me@foo.com/Bar"));

CPPUNIT_ASSERT(sessionStarted_);

}

std::auto_ptr<MockSession> session(createSession("me@foo.com/Bar"));

session->start();

getMockServer()->expectStreamStart();

getMockServer()->sendStreamFeatures();

processEvents();

CPPUNIT_ASSERT(session->getWhitespacePingLayer());

void testReceiveElementAfterSessionStarted() {

std::auto_ptr<MockSession> session(createSession("me@foo.com/Bar"));

getMockServer()->sendStreamFeatures();

processEvents();

}

std::auto_ptr<MockSession> session(createSession("me@foo.com/Bar"));

session->onElementReceived.connect(boost::bind(&SessionTest::addReceivedElement, this, _1));

session->start();

getMockServer()->sendMessage();

processEvents();

private:

struct MockConnection;

needCredentials_ = true;

}

private:

struct MockConnection : public Connection, public XMPPParserClient {

direction(direction), type(type), element(element) {}

Direction direction;

boost::shared_ptr<Element> element;

};

fail_(fail),

resetParser_(false),

parser_(0),

parser_ = new XMPPParser(this, &payloadParserFactories_);

}

void disconnect() {

}

if (fail_) {

MainEventLoop::postEvent(boost::bind(boost::ref(onError), Connection::ConnectionError));

}

else {

MainEventLoop::postEvent(boost::bind(boost::ref(onConnected)));

}

}

}

void handleStreamStart(const String&, const String& to, const String&) {

handleEvent(Event::StreamStartEvent);

}

String serializeEvent(const Event& event) {

switch (event.type) {

case Event::StreamStartEvent:

case Event::ElementEvent:

return serializer_.serializeElement(event.element);

case Event::StreamEndEvent:

}

void expectAuth(const String& user, const String& password) {

events_.push_back(Event(Event::In, Event::ElementEvent, boost::shared_ptr<AuthRequest>(new AuthRequest("PLAIN", ByteArray(s.getUTF8Data(), s.getUTF8Size())))));

}

void expectSessionStart(const String& id) {

events_.push_back(Event(Event::In, Event::ElementEvent, IQ::createRequest(IQ::Set, JID(), id, boost::shared_ptr<StartSession>(new StartSession()))));

}

events_.push_back(Event(Event::In, Event::ElementEvent, boost::shared_ptr<Message>(new Message())));

void sendInvalidXML() {

sendData("<invalid xml/>");

bool fail_;

bool resetParser_;

FullPayloadParserFactoryCollection payloadParserFactories_;

FullPayloadSerializerCollection payloadSerializers_;

XMPPParser* parser_;

struct MockConnectionFactory : public ConnectionFactory {

MockConnectionFactory() : fail_(false) {}

connections_.push_back(result);

return result;

}

FullPayloadSerializerCollection payloadSerializers_;

bool sessionStarted_;

bool needCredentials_;

typedef std::vector< boost::function<void ()> > EventQueue;

EventQueue events_;

};