#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/JID/JID.h>

#include <Swiften/MUC/MUCRegistry.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/StringCodecs/Hexify.h>

#include <Swiften/VCards/VCardManager.h>

#include <Swiften/VCards/VCardMemoryStorage.h>

using namespace Swift;

class CombinedAvatarProviderTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(CombinedAvatarProviderTest);

CPPUNIT_TEST(testGetAvatarWithNoAvatarProviderReturnsEmpty);

CPPUNIT_TEST(testGetAvatarWithSingleAvatarProvider);

CPPUNIT_TEST(testGetAvatarWithMultipleAvatarProviderReturnsFirstAvatar);

CPPUNIT_TEST(testGetAvatarWithMultipleAvatarProviderAndFailingFirstProviderReturnsSecondAvatar);

CPPUNIT_TEST(testProviderUpdateTriggersChange);

CPPUNIT_TEST(testProviderUpdateWithoutChangeDoesNotTriggerChange);

CPPUNIT_TEST(testProviderSecondUpdateTriggersChange);

CPPUNIT_TEST(testProviderUpdateWithAvatarDisappearingTriggersChange);

CPPUNIT_TEST(testProviderUpdateAfterAvatarDisappearedTriggersChange);

CPPUNIT_TEST(testProviderUpdateAfterGetDoesNotTriggerChange);

CPPUNIT_TEST(testProviderUpdateBareJIDAfterGetFullJID);

CPPUNIT_TEST(testRemoveProviderDisconnectsUpdates);

CPPUNIT_TEST(testAddRemoveFallthrough);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

user1 = JID("user1@bar.com/bla");

user2 = JID("user2@foo.com/baz");

avatarHash1 = "ABCDEFG";

avatarHash2 = "XYZU";

avatarHash3 = "IDGH";

}

void testGetAvatarWithNoAvatarProviderReturnsEmpty() {

std::shared_ptr<CombinedAvatarProvider> testling(createProvider());

boost::optional<std::string> hash = testling->getAvatarHash(user1);

CPPUNIT_ASSERT(!hash);

}

void testGetAvatarWithSingleAvatarProvider() {

std::shared_ptr<CombinedAvatarProvider> testling(createProvider());

avatarProvider1->avatars[user1] = avatarHash1;

testling->addProvider(avatarProvider1.get());

boost::optional<std::string> hash = testling->getAvatarHash(user1);

CPPUNIT_ASSERT(hash);

CPPUNIT_ASSERT_EQUAL(avatarHash1, *hash);

}

void testGetAvatarWithMultipleAvatarProviderReturnsFirstAvatar() {

std::shared_ptr<CombinedAvatarProvider> testling(createProvider());

avatarProvider1->avatars[user1] = avatarHash1;

avatarProvider2->avatars[user1] = avatarHash2;

testling->addProvider(avatarProvider1.get());

testling->addProvider(avatarProvider2.get());

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Client/ClientXMLTracer.h>

#include <iostream>

#include <boost/bind.hpp>

#include <Swiften/Base/Platform.h>

namespace Swift {

ClientXMLTracer::ClientXMLTracer(CoreClient* client, bool bosh) : bosh_(bosh) {

#ifdef SWIFTEN_PLATFORM_WIN32

#else

#endif

onDataReadConnection_ = client->onDataRead.connect(boost::bind(&ClientXMLTracer::printData, this, '<', _1));

onDataWrittenConnection_ = client->onDataWritten.connect(boost::bind(&ClientXMLTracer::printData, this, '>', _1));

}

void ClientXMLTracer::printData(char direction, const SafeByteArray& data) {

if (bosh_) {

printLine(direction);

std::string line = byteArrayToString(ByteArray(data.begin(), data.end()));

// Disabled because it swallows bits of XML (namespaces, if I recall)

// size_t endOfHTTP = line.find("\r\n\r\n");

// if (false && endOfHTTP != std::string::npos) {

// std::cerr << line.substr(0, endOfHTTP) << std::endl << beautifier->beautify(line.substr(endOfHTTP)) << std::endl;

// }

// else {

std::cerr << line << std::endl;

// }

}

else {

const auto& str = beautifier_->beautify(byteArrayToString(ByteArray(data.begin(), data.end())));

if (beautifier_->wasReset()) {

printLine(direction);

}

std::cerr << str;

if (beautifier_->getLevel() <= 1) {

std::cerr << std::endl;

}

}

/*

* Copyright (c) 2010-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include "gtest/gtest.h"

#include <Swiften/Client/XMLBeautifier.h>

#include <iostream>

using namespace Swift;

namespace {

const static std::string FULL_FORMATTED_OUTPUT("<list>\n <el>aqq</el>\n <el>bzz</el>\n</list>");

}

TEST(XMLBeautifierTest, testBeautify) {

ASSERT_EQ(FULL_FORMATTED_OUTPUT, beautifier->beautify("<list><el>aqq</el><el>bzz</el></list>"));

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

ASSERT_EQ(FULL_FORMATTED_OUTPUT, beautifier->beautify("<list><el>aqq</el><el>bzz</el></list>"));

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

}

TEST(XMLBeautifierTest, testBeautifyMultipleChunks) {

auto result = beautifier->beautify("<list><el>aqq</el>");

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(1, beautifier->getLevel());

result += beautifier->beautify("<el>bzz</el></list>");

ASSERT_FALSE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

ASSERT_EQ(FULL_FORMATTED_OUTPUT, result);

}

TEST(XMLBeautifierTest, testBeautifyMultipleChunksMiddleElement) {

auto result = beautifier->beautify("<l");

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

result += beautifier->beautify("ist><el>aqq</el><el>bzz</el></list>");

ASSERT_FALSE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

ASSERT_EQ(FULL_FORMATTED_OUTPUT, result);

}

TEST(XMLBeautifierTest, testBeautifyInvalidMultipleChunks) {

ASSERT_EQ(std::string("<list>\n <el>aqq"), beautifier->beautify("<list><el>aqq<"));

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(2, beautifier->getLevel());

ASSERT_EQ(FULL_FORMATTED_OUTPUT, beautifier->beautify("<list><el>aqq</el><el>bzz</el></list>"));

ASSERT_TRUE(beautifier->wasReset());

ASSERT_EQ(0, beautifier->getLevel());

}

#include <Swiften/Disco/CapsMemoryStorage.h>

#include <Swiften/Elements/CapsInfo.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/Queries/IQRouter.h>

using namespace Swift;

class CapsManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(CapsManagerTest);

CPPUNIT_TEST(testReceiveNewHashRequestsDisco);

CPPUNIT_TEST(testReceiveSameHashDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveLegacyCapsDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveSameHashFromSameUserAfterFailedDiscoDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveSameHashFromDifferentUserAfterFailedDiscoRequestsDisco);

CPPUNIT_TEST(testReceiveSameHashFromDifferentUserAfterIncorrectVerificationRequestsDisco);

CPPUNIT_TEST(testReceiveDifferentHashFromSameUserAfterFailedDiscoDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveSameHashAfterSuccesfulDiscoDoesNotRequestDisco);

CPPUNIT_TEST(testReceiveSuccesfulDiscoStoresCaps);

CPPUNIT_TEST(testReceiveIncorrectVerificationDiscoDoesNotStoreCaps);

CPPUNIT_TEST(testReceiveFailingDiscoFallsBack);

CPPUNIT_TEST(testReceiveNoDiscoFallsBack);

CPPUNIT_TEST(testReceiveFailingFallbackDiscoFallsBack);

CPPUNIT_TEST(testReceiveSameHashFromFailingUserAfterReconnectRequestsDisco);

CPPUNIT_TEST(testReconnectResetsFallback);

CPPUNIT_TEST(testReconnectResetsRequests);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

user1 = JID("user1@bar.com/bla");

discoInfo1 = std::make_shared<DiscoInfo>();

discoInfo1->addFeature("http://swift.im/feature1");

capsInfo1 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node1.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

capsInfo1alt = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

user2 = JID("user2@foo.com/baz");

discoInfo2 = std::make_shared<DiscoInfo>();

discoInfo2->addFeature("http://swift.im/feature2");

capsInfo2 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo2.get()));

user3 = JID("user3@foo.com/baz");

legacyCapsInfo = std::make_shared<CapsInfo>("http://swift.im", "ver1", "");

}

void tearDown() {

iqRouter.reset();

}

void testReceiveNewHashRequestsDisco() {

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

sendPresenceWithCaps(user1, capsInfo1);

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

std::shared_ptr<DiscoInfo> discoInfo(stanzaChannel->sentStanzas[0]->getPayload<DiscoInfo>());

CPPUNIT_ASSERT(discoInfo);

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

}

void testReceiveSameHashDoesNotRequestDisco() {

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

sendPresenceWithCaps(user1, capsInfo1);

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Crypto/CryptoProvider.h>

#include <Swiften/Crypto/PlatformCryptoProvider.h>

#include <Swiften/Disco/CapsInfoGenerator.h>

#include <Swiften/Disco/CapsProvider.h>

#include <Swiften/Disco/EntityCapsManager.h>

#include <Swiften/Elements/CapsInfo.h>

using namespace Swift;

class EntityCapsManagerTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(EntityCapsManagerTest);

CPPUNIT_TEST(testReceiveKnownHash);

CPPUNIT_TEST(testReceiveKnownHashTwiceDoesNotTriggerChange);

CPPUNIT_TEST(testReceiveUnknownHashDoesNotTriggerChange);

CPPUNIT_TEST(testReceiveUnknownHashAfterKnownHashTriggersChangeAndClearsCaps);

CPPUNIT_TEST(testReceiveUnavailablePresenceAfterKnownHashTriggersChangeAndClearsCaps);

CPPUNIT_TEST(testReconnectTriggersChangeAndClearsCaps);

CPPUNIT_TEST(testHashAvailable);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

user1 = JID("user1@bar.com/bla");

discoInfo1 = std::make_shared<DiscoInfo>();

discoInfo1->addFeature("http://swift.im/feature1");

capsInfo1 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node1.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

capsInfo1alt = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo1.get()));

user2 = JID("user2@foo.com/baz");

discoInfo2 = std::make_shared<DiscoInfo>();

discoInfo2->addFeature("http://swift.im/feature2");

capsInfo2 = std::make_shared<CapsInfo>(CapsInfoGenerator("http://node2.im", crypto.get()).generateCapsInfo(*discoInfo2.get()));

user3 = JID("user3@foo.com/baz");

legacyCapsInfo = std::make_shared<CapsInfo>("http://swift.im", "ver1", "");

}

void testReceiveKnownHash() {

std::shared_ptr<EntityCapsManager> testling = createManager();

capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

sendPresenceWithCaps(user1, capsInfo1);

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

CPPUNIT_ASSERT_EQUAL(user1, changes[0]);

CPPUNIT_ASSERT_EQUAL(discoInfo1, testling->getCaps(user1));

}

void testReceiveKnownHashTwiceDoesNotTriggerChange() {

std::shared_ptr<EntityCapsManager> testling = createManager();

capsProvider->caps[capsInfo1->getVersion()] = discoInfo1;

sendPresenceWithCaps(user1, capsInfo1);

changes.clear();

#include <Swiften/EventLoop/DummyEventLoop.h>

#include <Swiften/FileTransfer/ByteArrayReadBytestream.h>

#include <Swiften/FileTransfer/ByteArrayWriteBytestream.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/DummyConnection.h>

#include <Swiften/Network/DummyTimerFactory.h>

#include <Swiften/StringCodecs/Hexify.h>

using namespace Swift;

static boost::mt19937 randomGen;

class SOCKS5BytestreamClientSessionTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(SOCKS5BytestreamClientSessionTest);

CPPUNIT_TEST(testForSessionReady);

CPPUNIT_TEST(testErrorHandlingHello);

CPPUNIT_TEST(testErrorHandlingRequest);

CPPUNIT_TEST(testWriteBytestream);

CPPUNIT_TEST(testReadBytestream);

CPPUNIT_TEST_SUITE_END();

public:

SOCKS5BytestreamClientSessionTest() : destinationAddressPort(HostAddressPort(HostAddress::fromString("127.0.0.1").get(), 8888)) {}

void setUp() {

crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());

destination = "092a44d859d19c9eed676b551ee80025903351c2";

randomGen.seed(static_cast<unsigned int>(time(nullptr)));

connection = std::make_shared<MockeryConnection>(failingPorts, true, eventLoop.get());

//connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));

//stream1 = std::make_shared<ByteArrayReadBytestream>(createByteArray("abcdefg")));

// connection->onDataRead.connect(boost::bind(&SOCKS5BytestreamClientSessionTest::handleDataRead, this, _1));

}

void tearDown() {

//connection.reset();

}

void testForSessionReady() {

TestHelper helper;

connection->onDataSent.connect(boost::bind(&TestHelper::handleConnectionDataWritten, &helper, _1));

SOCKS5BytestreamClientSession::ref clientSession = std::make_shared<SOCKS5BytestreamClientSession>(connection, destinationAddressPort, destination, timerFactory.get());

clientSession->onSessionReady.connect(boost::bind(&TestHelper::handleSessionReady, &helper, _1));

clientSession->start();

eventLoop->processEvents();

CPPUNIT_ASSERT(createByteArray("\x05\x01\x00", 3) == helper.unprocessedInput);

helper.unprocessedInput.clear();

serverRespondHelloOK();

eventLoop->processEvents();

CPPUNIT_ASSERT_EQUAL(createByteArray("\x05\x01\x00\x03", 4), createByteArray(&helper.unprocessedInput[0], 4));

CPPUNIT_ASSERT_EQUAL(createByteArray(static_cast<char>(destination.size())), createByteArray(static_cast<char>(helper.unprocessedInput[4])));

CPPUNIT_ASSERT_EQUAL(createByteArray(destination), createByteArray(&helper.unprocessedInput[5], destination.size()));

CPPUNIT_ASSERT_EQUAL(createByteArray("\x00", 1), createByteArray(&helper.unprocessedInput[5 + destination.size()], 1));

helper.unprocessedInput.clear();

/*

* Copyright (c) 2010 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Parser/PlatformXMLParserFactory.h>

#include <cassert>

#ifdef HAVE_LIBXML

#include <Swiften/Parser/LibXMLParser.h>

#else

#include <Swiften/Parser/ExpatParser.h>

#endif

namespace Swift {

PlatformXMLParserFactory::PlatformXMLParserFactory() {

}

std::unique_ptr<XMLParser> PlatformXMLParserFactory::createXMLParser(XMLParserClient* client) {

#ifdef HAVE_LIBXML

#else

#endif

}

}

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <memory>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Client/DummyStanzaChannel.h>

#include <Swiften/Presence/DirectedPresenceSender.h>

#include <Swiften/Presence/StanzaChannelPresenceSender.h>

using namespace Swift;

class DirectedPresenceSenderTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(DirectedPresenceSenderTest);

CPPUNIT_TEST(testSendPresence);

CPPUNIT_TEST(testSendPresence_UndirectedPresenceWithDirectedPresenceReceivers);

CPPUNIT_TEST(testSendPresence_DirectedPresenceWithDirectedPresenceReceivers);

CPPUNIT_TEST(testAddDirectedPresenceReceiver);

CPPUNIT_TEST(testAddDirectedPresenceReceiver_WithoutSendingPresence);

CPPUNIT_TEST(testAddDirectedPresenceReceiver_AfterSendingDirectedPresence);

CPPUNIT_TEST(testRemoveDirectedPresenceReceiver);

CPPUNIT_TEST(testRemoveDirectedPresenceReceiver_WithoutSendingPresence);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

testPresence = std::make_shared<Presence>();

testPresence->setStatus("Foo");

secondTestPresence = std::make_shared<Presence>();

secondTestPresence->setStatus("Bar");

}

void testSendPresence() {

std::shared_ptr<DirectedPresenceSender> testling(createPresenceSender());

testling->sendPresence(testPresence);

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

std::shared_ptr<Presence> presence = std::dynamic_pointer_cast<Presence>(channel->sentStanzas[0]);

CPPUNIT_ASSERT(testPresence == presence);

}

void testSendPresence_UndirectedPresenceWithDirectedPresenceReceivers() {

std::shared_ptr<DirectedPresenceSender> testling(createPresenceSender());

testling->addDirectedPresenceReceiver(JID("alice@wonderland.lit/teaparty"), DirectedPresenceSender::AndSendPresence);

testling->sendPresence(testPresence);

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

std::shared_ptr<Presence> presence = std::dynamic_pointer_cast<Presence>(channel->sentStanzas[0]);

CPPUNIT_ASSERT(testPresence == presence);

presence = std::dynamic_pointer_cast<Presence>(channel->sentStanzas[1]);

CPPUNIT_ASSERT_EQUAL(testPresence->getStatus(), presence->getStatus());

CPPUNIT_ASSERT_EQUAL(JID("alice@wonderland.lit/teaparty"), presence->getTo());

}

void testSendPresence_DirectedPresenceWithDirectedPresenceReceivers() {

std::shared_ptr<DirectedPresenceSender> testling(createPresenceSender());

testling->addDirectedPresenceReceiver(JID("alice@wonderland.lit/teaparty"), DirectedPresenceSender::AndSendPresence);

channel->sentStanzas.clear();

#include <memory>

#include <boost/bind.hpp>

#include <QA/Checker/IO.h>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/TLS/CertificateFactory.h>

#include <SwifTools/Application/PlatformApplicationPathProvider.h>

using namespace Swift;

template<typename CERTIFICATE_FACTORY>

class CertificateTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(CertificateTest);

CPPUNIT_TEST(testConstructFromDER);

CPPUNIT_TEST(testToDER);

//CPPUNIT_TEST(testGetSubjectName);

CPPUNIT_TEST(testGetCommonNames);

CPPUNIT_TEST(testGetSRVNames);

CPPUNIT_TEST(testGetDNSNames);

CPPUNIT_TEST(testGetXMPPAddresses);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

readByteArrayFromFile(certificateData, (pathProvider->getExecutableDir() / "jabber_org.crt"));

certificateFactory = std::unique_ptr<CertificateFactory>(new CERTIFICATE_FACTORY());

}

void testConstructFromDER() {

Certificate::ref testling = Certificate::ref(certificateFactory->createCertificateFromDER(certificateData));

CPPUNIT_ASSERT_EQUAL(std::string("*.jabber.org"), testling->getCommonNames()[0]);

}

void testToDER() {

Certificate::ref testling = Certificate::ref(certificateFactory->createCertificateFromDER(certificateData));

CPPUNIT_ASSERT_EQUAL(certificateData, testling->toDER());

}

/*

void testGetSubjectName() {

Certificate::ref testling = Certificate::ref(certificateFactory->createCertificateFromDER(certificateData);

CPPUNIT_ASSERT_EQUAL(std::string("/description=114072-VMk8pdi1aj5kTXxO/C=US/ST=Colorado/L=Denver/O=Peter Saint-Andre/OU=StartCom Trusted Certificate Member/CN=*.jabber.org/emailAddress=hostmaster@jabber.org"), testling->getSubjectName());

}

*/

void testGetCommonNames() {

Certificate::ref testling = Certificate::ref(certificateFactory->createCertificateFromDER(certificateData));

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(testling->getCommonNames().size()));

CPPUNIT_ASSERT_EQUAL(std::string("*.jabber.org"), testling->getCommonNames()[0]);

}

#include <memory>

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Elements/Payload.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Requests/GetPrivateStorageRequest.h>

using namespace Swift;

class GetPrivateStorageRequestTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(GetPrivateStorageRequestTest);

CPPUNIT_TEST(testSend);

CPPUNIT_TEST(testHandleResponse);

CPPUNIT_TEST(testHandleResponse_Error);

CPPUNIT_TEST_SUITE_END();

public:

class MyPayload : public Payload {

public:

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

std::string text;

};

public:

void setUp() {

}

void tearDown() {

router.reset();

}

void testSend() {

GetPrivateStorageRequest<MyPayload>::ref request = GetPrivateStorageRequest<MyPayload>::create(router.get());

request->send();

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

CPPUNIT_ASSERT_EQUAL(JID(), channel->iqs_[0]->getTo());

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

std::shared_ptr<PrivateStorage> storage = channel->iqs_[0]->getPayload<PrivateStorage>();

CPPUNIT_ASSERT(storage);

std::shared_ptr<MyPayload> payload = std::dynamic_pointer_cast<MyPayload>(storage->getPayload());

CPPUNIT_ASSERT(payload);

}

void testHandleResponse() {

GetPrivateStorageRequest<MyPayload>::ref testling = GetPrivateStorageRequest<MyPayload>::create(router.get());

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

testling->send();

channel->onIQReceived(createResponse("test-id", "foo"));

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

CPPUNIT_ASSERT_EQUAL(std::string("foo"), std::dynamic_pointer_cast<MyPayload>(responses[0])->text);

}

void testHandleResponse_Error() {

*/

#include <memory>

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Elements/SoftwareVersion.h>

#include <Swiften/Queries/DummyIQChannel.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Queries/Responder.h>

using namespace Swift;

class ResponderTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(ResponderTest);

CPPUNIT_TEST(testConstructor);

CPPUNIT_TEST(testStart);

CPPUNIT_TEST(testStop);

CPPUNIT_TEST(testHandleIQ_Set);

CPPUNIT_TEST(testHandleIQ_Get);

CPPUNIT_TEST(testHandleIQ_Error);

CPPUNIT_TEST(testHandleIQ_Result);

CPPUNIT_TEST(testHandleIQ_NoPayload);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

payload_ = std::make_shared<SoftwareVersion>("foo");

}

void tearDown() {

router_.reset();

}

void testConstructor() {

MyResponder testling(router_.get());

channel_->onIQReceived(createRequest(IQ::Set));

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

}

void testStart() {

MyResponder testling(router_.get());

testling.start();

channel_->onIQReceived(createRequest(IQ::Set));

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

}

void testStop() {

MyResponder testling(router_.get());

testling.start();

testling.stop();

channel_->onIQReceived(createRequest(IQ::Set));

* All rights reserved.

* See the COPYING file for more information.

*/

#include <memory>

#include <boost/bind.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

#include <Swiften/Roster/UnitTest/XMPPRosterSignalHandler.h>

#include <Swiften/Roster/XMPPRosterImpl.h>

using namespace Swift;

class XMPPRosterImplTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(XMPPRosterImplTest);

CPPUNIT_TEST(testJIDAdded);

CPPUNIT_TEST(testJIDRemoved);

CPPUNIT_TEST(testJIDUpdated);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

jid1_ = JID("a@b.c");

jid2_ = JID("b@c.d");

jid3_ = JID("c@d.e");

groups1_.push_back("bobs");

groups1_.push_back("berts");

groups2_.push_back("ernies");

}

void testJIDAdded() {

roster_->addContact(jid1_, "NewName", groups1_, RosterItemPayload::Both);

CPPUNIT_ASSERT_EQUAL(Add, handler_->getLastEvent());

CPPUNIT_ASSERT_EQUAL(jid1_, handler_->getLastJID());

CPPUNIT_ASSERT_EQUAL(std::string("NewName"), roster_->getNameForJID(jid1_));

CPPUNIT_ASSERT(groups1_ == roster_->getGroupsForJID(jid1_));

handler_->reset();

roster_->addContact(jid2_, "NameTwo", groups1_, RosterItemPayload::Both);

CPPUNIT_ASSERT_EQUAL(Add, handler_->getLastEvent());

CPPUNIT_ASSERT_EQUAL(jid2_, handler_->getLastJID());

CPPUNIT_ASSERT_EQUAL(std::string("NameTwo"), roster_->getNameForJID(jid2_));

CPPUNIT_ASSERT_EQUAL(std::string("NewName"), roster_->getNameForJID(jid1_));

CPPUNIT_ASSERT(groups1_ == roster_->getGroupsForJID(jid2_));

CPPUNIT_ASSERT(groups1_ == roster_->getGroupsForJID(jid1_));

handler_->reset();

roster_->addContact(jid3_, "NewName", groups2_, RosterItemPayload::Both);

CPPUNIT_ASSERT_EQUAL(Add, handler_->getLastEvent());

CPPUNIT_ASSERT_EQUAL(jid3_, handler_->getLastJID());

CPPUNIT_ASSERT_EQUAL(std::string("NewName"), roster_->getNameForJID(jid3_));

CPPUNIT_ASSERT(groups2_ == roster_->getGroupsForJID(jid3_));

}

void testJIDRemoved() {

roster_->addContact(jid1_, "NewName", groups1_, RosterItemPayload::Both);

handler_->reset();