}

void handleAvatarChanged(const JID& jid) {

changes.push_back(jid);

}

void sendVCardResult() {

VCard::ref vcard(new VCard());

vcard->setFullName("Foo Bar");

}

private:

struct DummyMUCRegistry : public MUCRegistry {

bool isMUC(const JID& jid) const { return std::find(mucs_.begin(), mucs_.end(), jid) != mucs_.end(); }

std::vector<JID> mucs_;

};

JID ownJID;

presence->addPayload(boost::shared_ptr<VCardUpdate>(new VCardUpdate(hash)));

return presence;

}

IQ::ref createVCardResult(const ByteArray& avatar) {

VCard::ref vcard(new VCard());

if (!avatar.isEmpty()) {

vcard->setPhoto(avatar);

}

}

void handleAvatarChanged(const JID& jid) {

changes.push_back(jid);

}

private:

struct DummyMUCRegistry : public MUCRegistry {

bool isMUC(const JID& jid) const { return std::find(mucs_.begin(), mucs_.end(), jid) != mucs_.end(); }

CoreClient::CoreClient(const JID& jid, const std::string& password, NetworkFactories* networkFactories) : jid_(jid), password_(password), networkFactories(networkFactories), useStreamCompression(true), useTLS(UseTLSWhenAvailable), disconnectRequested_(false), certificateTrustChecker(NULL) {

stanzaChannel_ = new ClientSessionStanzaChannel();

stanzaChannel_->onMessageReceived.connect(boost::bind(&CoreClient::handleMessageReceived, this, _1));

stanzaChannel_->onPresenceReceived.connect(boost::bind(&CoreClient::handlePresenceReceived, this, _1));

stanzaChannel_->onStanzaAcked.connect(boost::bind(&CoreClient::handleStanzaAcked, this, _1));

stanzaChannel_->onAvailableChanged.connect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1));

iqRouter_ = new IQRouter(stanzaChannel_);

tlsFactories = new PlatformTLSFactories();

}

CoreClient::~CoreClient() {

if ((session_ && !session_->isFinished()) || connection_) {

std::cerr << "Warning: Client not disconnected properly" << std::endl;

}

delete tlsFactories;

delete iqRouter_;

stanzaChannel->sentStanzas.clear();

sendPresenceWithCaps(user1, capsInfo1);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(stanzaChannel->sentStanzas.size()));

}

void testReceiveSameHashFromDifferentUserAfterFailedDiscoRequestsDisco() {

std::auto_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

stanzaChannel->sentStanzas.clear();

sendPresenceWithCaps(user2, capsInfo1);

CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user2, IQ::Get));

}

void testReceiveSameHashFromDifferentUserAfterIncorrectVerificationRequestsDisco() {

std::auto_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

boost::shared_ptr<DiscoInfo> discoInfo(storage->getDiscoInfo(capsInfo1->getVersion()));

CPPUNIT_ASSERT(!discoInfo);

}

void testReceiveFailingDiscoFallsBack() {

std::auto_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

sendPresenceWithCaps(user2, capsInfo1alt);

CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(1, user2, IQ::Get));

boost::shared_ptr<DiscoInfo> discoInfo(stanzaChannel->sentStanzas[1]->getPayload<DiscoInfo>());

CPPUNIT_ASSERT(discoInfo);

CPPUNIT_ASSERT_EQUAL("http://node2.im#" + capsInfo1alt->getVersion(), discoInfo->getNode());

}

void testReceiveFailingFallbackDiscoFallsBack() {

std::auto_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

sendPresenceWithCaps(user2, capsInfo1alt);

sendPresenceWithCaps(user3, capsInfo1);

CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(2, user3, IQ::Get));

}

void testReceiveSameHashFromFailingUserAfterReconnectRequestsDisco() {

std::auto_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

stanzaChannel->setAvailable(false);

stanzaChannel->setAvailable(true);

stanzaChannel->sentStanzas.clear();

sendPresenceWithCaps(user1, capsInfo1);

CPPUNIT_ASSERT(stanzaChannel->isRequestAtIndex<DiscoInfo>(0, user1, IQ::Get));

}

void testReconnectResetsFallback() {

std::auto_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

sendPresenceWithCaps(user2, capsInfo1alt);

stanzaChannel->setAvailable(false);

stanzaChannel->setAvailable(true);

stanzaChannel->sentStanzas.clear();

sendPresenceWithCaps(user1, capsInfo1);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(stanzaChannel->sentStanzas.size()));

}

void testReconnectResetsRequests() {

std::auto_ptr<CapsManager> testling = createManager();

sendPresenceWithCaps(user1, capsInfo1);

stanzaChannel->sentStanzas.clear();

stanzaChannel->setAvailable(false);

void sendPresenceWithCaps(const JID& jid, boost::shared_ptr<CapsInfo> caps) {

boost::shared_ptr<Presence> presence(new Presence());

presence->setFrom(jid);

presence->addPayload(caps);

stanzaChannel->onPresenceReceived(presence);

}

void sendDiscoInfoResult(boost::shared_ptr<DiscoInfo> discoInfo) {

}

private:

DummyStanzaChannel* stanzaChannel;

IQRouter* iqRouter;

CapsStorage* storage;

std::vector<JID> changes;

JID user1;

boost::shared_ptr<DiscoInfo> discoInfo1;

CPPUNIT_ASSERT(finished);

CPPUNIT_ASSERT(!error);

}

void testErrorResponseFinishesWithError() {

std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

testling->setBlockSize(3);

testling->start();

CPPUNIT_ASSERT(finished);

CPPUNIT_ASSERT(error);

}

void testStopDuringSessionCloses() {

std::auto_ptr<IBBSendSession> testling = createSession("foo@bar.com/baz");

testling->setBlockSize(3);

testling->start();

CPPUNIT_ASSERT(finished);

testling->stop();

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(stanzaChannel->sentStanzas.size()));

}

private:

IQ::ref createIBBResult() {

}

private:

std::auto_ptr<IBBSendSession> createSession(const std::string& to) {

std::auto_ptr<IBBSendSession> session(new IBBSendSession("myid", JID(to), bytestream, iqRouter));

session->onFinished.connect(boost::bind(&IBBSendSessionTest::handleFinished, this, _1));

return session;

}

class IQChannel;

class IQHandler;

class IQRouter {

public:

IQRouter(IQChannel* channel);

~IQRouter();

/**

* Sets the 'from' JID for all outgoing IQ stanzas.

*

* By default, IQRouter does not add a from to IQ stanzas, since

* this is automatically added by the server. This overrides this

* default behavior, which is necessary for e.g. components.

*/

void setFrom(const JID& from) {

from_ = from;

}

bool isAvailable();

private:

void handleIQ(boost::shared_ptr<IQ> iq);

void processPendingRemoves();

private:

IQChannel* channel_;

JID from_;

std::vector< boost::shared_ptr<IQHandler> > handlers_;

std::vector< boost::shared_ptr<IQHandler> > queuedRemoves_;

bool queueRemoves_;

};

}

}

router_->sendIQ(iq);

}

bool Request::handleIQ(boost::shared_ptr<IQ> iq) {

bool handled = false;

if (iq->getType() == IQ::Result || iq->getType() == IQ::Error) {

if (sent_ && iq->getID() == id_) {

}

else {

}

}

}

}

return handled;

}

}

Payload::ref getPayload() const {

return payload_;

}

virtual void handleResponse(Payload::ref, ErrorPayload::ref) = 0;

private:

bool handleIQ(boost::shared_ptr<IQ>);

private:

IQRouter* router_;

IQ::Type type_;

JID receiver_;

boost::shared_ptr<Payload> payload_;

std::string id_;

bool sent_;

};

CPPUNIT_TEST(testHandleIQ);

CPPUNIT_TEST(testHandleIQ_InvalidID);

CPPUNIT_TEST(testHandleIQ_Error);

CPPUNIT_TEST(testHandleIQ_ErrorWithoutPayload);

CPPUNIT_TEST(testHandleIQ_BeforeSend);

CPPUNIT_TEST(testHandleIQ_DifferentPayload);

CPPUNIT_TEST(testHandleIQ_RawXMLPayload);

CPPUNIT_TEST(testHandleIQ_GetWithSameID);

CPPUNIT_TEST(testHandleIQ_SetWithSameID);

CPPUNIT_TEST_SUITE_END();

public:

class MyPayload : public Payload {

public:

MyPayload(const std::string& s = "") : text_(s) {}

std::string text_;

};

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

CPPUNIT_ASSERT_EQUAL(IQ::Get, channel_->iqs_[0]->getType());

}

void testHandleIQ() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleResponse, this, _1, _2));

testling.send();

CPPUNIT_ASSERT_EQUAL(1, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

}

// FIXME: Doesn't test that it didn't handle the payload

void testHandleIQ_InvalidID() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleResponse, this, _1, _2));

testling.send();

CPPUNIT_ASSERT_EQUAL(0, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

}

void testHandleIQ_Error() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleResponse, this, _1, _2));

testling.send();

boost::shared_ptr<Payload> errorPayload = boost::shared_ptr<ErrorPayload>(new ErrorPayload(ErrorPayload::InternalServerError));

error->addPayload(errorPayload);

channel_->onIQReceived(error);

CPPUNIT_ASSERT_EQUAL(0, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

CPPUNIT_ASSERT_EQUAL(ErrorPayload::InternalServerError, receivedErrors[0].getCondition());

}

void testHandleIQ_ErrorWithoutPayload() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleResponse, this, _1, _2));

testling.send();

CPPUNIT_ASSERT_EQUAL(0, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

CPPUNIT_ASSERT_EQUAL(ErrorPayload::UndefinedCondition, receivedErrors[0].getCondition());

}

void testHandleIQ_BeforeSend() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleResponse, this, _1, _2));

CPPUNIT_ASSERT_EQUAL(0, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(channel_->iqs_.size()));

}

void testHandleIQ_DifferentPayload() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleDifferentResponse, this, _1, _2));

testling.send();

responsePayload_ = boost::make_shared<MyOtherPayload>();

CPPUNIT_ASSERT_EQUAL(1, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

}

void testHandleIQ_RawXMLPayload() {

payload_ = boost::make_shared<RawXMLPayload>("<bla/>");

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleRawXMLResponse, this, _1, _2));

testling.send();

responsePayload_ = boost::make_shared<MyOtherPayload>();

CPPUNIT_ASSERT_EQUAL(1, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(channel_->iqs_.size()));

}

void testHandleIQ_GetWithSameID() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleResponse, this, _1, _2));

testling.send();

response->setType(IQ::Get);

channel_->onIQReceived(response);

CPPUNIT_ASSERT_EQUAL(0, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(channel_->iqs_.size()));

}

void testHandleIQ_SetWithSameID() {

MyRequest testling(IQ::Get, JID("foo@bar.com/baz"), payload_, router_);

testling.onResponse.connect(boost::bind(&RequestTest::handleResponse, this, _1, _2));

testling.send();

response->setType(IQ::Set);

channel_->onIQReceived(response);

CPPUNIT_ASSERT_EQUAL(0, responsesReceived_);

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(receivedErrors.size()));

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(channel_->iqs_.size()));

}

private:

void handleResponse(boost::shared_ptr<Payload> p, ErrorPayload::ref e) {

if (e) {

receivedErrors.push_back(*e);

}

else {

boost::shared_ptr<MyPayload> payload(boost::dynamic_pointer_cast<MyPayload>(p));

CPPUNIT_ASSERT(payload);

}

void handleRawXMLResponse(boost::shared_ptr<Payload> p, ErrorPayload::ref e) {

CPPUNIT_ASSERT(!e);

CPPUNIT_ASSERT(p);

CPPUNIT_ASSERT(boost::dynamic_pointer_cast<MyOtherPayload>(p));

++responsesReceived_;

}

boost::shared_ptr<IQ> iq(new IQ(IQ::Result));

iq->addPayload(responsePayload_);

iq->setID(id);

return iq;

}

boost::shared_ptr<IQ> iq(new IQ(IQ::Error));

iq->setID(id);

return iq;

}

private:

IQRouter* router_;

DummyIQChannel* channel_;

boost::shared_ptr<Payload> payload_;

boost::shared_ptr<Payload> responsePayload_;

CPPUNIT_ASSERT_EQUAL(std::string("Foo Bar"), changes[0].second->getFullName());

CPPUNIT_ASSERT_EQUAL(std::string("Foo Bar"), vcardStorage->getVCard(JID("foo@bar.com/baz"))->getFullName());

CPPUNIT_ASSERT_EQUAL(0, static_cast<int>(ownChanges.size()));

}

void testRequest_Error() {

std::auto_ptr<VCardManager> testling = createManager();

testling->requestVCard(JID("foo@bar.com/baz"));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(changes.size()));

CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com/baz"), changes[0].first);

CPPUNIT_ASSERT_EQUAL(std::string(""), changes[0].second->getFullName());

CPPUNIT_ASSERT_EQUAL(std::string(""), vcardStorage->getVCard(JID("foo@bar.com/baz"))->getFullName());

}

void testRequest_VCardAlreadyRequested() {

std::auto_ptr<VCardManager> testling = createManager();

}

void handleOwnVCardChanged(VCard::ref vcard) {

ownChanges.push_back(vcard);

}

IQ::ref createVCardResult() {

VCard::ref vcard(new VCard());

vcard->setFullName("Foo Bar");

}

IQ::ref createOwnVCardResult() {

VCard::ref vcard(new VCard());

vcard->setFullName("Myself");

}

IQ::ref createSetVCardResult() {

}

private:

JID ownJID;

DummyStanzaChannel* stanzaChannel;

IQRouter* iqRouter;

VCardMemoryStorage* vcardStorage;

std::vector< std::pair<JID, VCard::ref> > changes;