}

}

rosterReceived = true;

std::cout << "Disconnecting" << std::endl;

client->disconnect();

static const std::string CLIENT_NAME = "Swiften FT Test";

static const std::string CLIENT_NODE = "http://swift.im";

BoostRandomGenerator randGen;

private:

int clientACandidates_;

std::map<std::string, ByteArray> clientASendFiles_;

int clientBCandidates_;

};

/**

/*

* All rights reserved.

* See the COPYING file for more information.

*/

public:

void setUp() {

eventLoop = new DummyEventLoop();

querier->start();

}

}

void testPublish() {

browseQuery->onServiceAdded.connect(boost::bind(&DNSSDTest::handleServiceAdded, this, _1));

browseQuery->onServiceRemoved.connect(boost::bind(&DNSSDTest::handleServiceRemoved, this, _1));

browseQuery->onError.connect(boost::bind(&DNSSDTest::handleBrowseError, this));

// Publish the service

LinkLocalServiceInfo info;

registerQuery->onRegisterFinished.connect(boost::bind(&DNSSDTest::handleRegisterFinished, this, _1));

registerQuery->registerService();

// Resolve all added services

for (size_t i = 0; i < added.size(); ++i) {

resolvedServices.clear();

resolveServiceQuery->onServiceResolved.connect(boost::bind(&DNSSDTest::handleResolveFinished, this, _1));

resolveServiceQuery->start();

wait();

private:

DummyEventLoop* eventLoop;

std::vector<DNSSDServiceID> added;

std::vector<DNSSDServiceID> registered;

std::vector<DNSSDServiceID> toRemove;

static const std::string CLIENT_NAME = "Swiften FT Test";

static const std::string CLIENT_NODE = "http://swift.im";

BoostRandomGenerator randGen;

class FileTransferTest {

public:

FileTransferTest(int senderCandidates, int receiverCandidates) : senderCandidates_(senderCandidates), senderError_(FileTransferError::UnknownError), senderIsDone_(false), receiverCandidates_(receiverCandidates), receiverError_(FileTransferError::UnknownError), receiverIsDone_(false) {

sender_->onDisconnected.connect(boost::bind(&FileTransferTest::handleSenderDisconnected, this, _1));

sender_->onConnected.connect(boost::bind(&FileTransferTest::handleSenderConnected, this));

sender_->getEntityCapsProvider()->onCapsChanged.connect(boost::bind(&FileTransferTest::handleSenderCapsChanged, this, _1));

receiver_->onConnected.connect(boost::bind(&FileTransferTest::handleReceiverConnected, this));

receiver_->onDisconnected.connect(boost::bind(&FileTransferTest::handleReceiverDisconnected, this, _1));

void handleReceiverIncomingFileTransfer(IncomingFileTransfer::ref transfer) {

incomingFileTransfers_.push_back(transfer);

transfer->onFinished.connect(boost::bind(&FileTransferTest::handleReceiverFileTransferFinished, this, _1, out));

FileTransferOptions options;

void handleSenderCapsChanged(const JID &jid) {

if (receiver_ && (receiver_->getJID().toBare() == jid.toBare())) {

FileTransferOptions options;

options = options.withInBandAllowed(senderCandidates_ & InBandBytestream);

}

}

out->close();

receiverError_ = error;

receiverIsDone_ = true;

private:

int senderCandidates_;

ClientXMLTracer* senderTracer_;

ByteArray sendData_;

OutgoingFileTransfer::ref outgoingFileTransfer_;

bool senderIsDone_;

int receiverCandidates_;

ClientXMLTracer* receiverTracer_;

ByteArray receiveData_;

std::vector<IncomingFileTransfer::ref> incomingFileTransfers_;

std::cout << "senderCandidates: " << senderCandidates << ", receiverCandidates: " << receiverCandidates << std::endl;

bool expectSuccess = (senderCandidates & receiverCandidates) > 0;

testRun->run();

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <string>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

stoppedError_ = e;

}

receivedNewConnection_ = true;

remoteAddress_ = connection->getRemoteAddress();

}

* See the COPYING file for more information.

*/

#include <string>

#include <boost/date_time/posix_time/posix_time_types.hpp>

#include <cppunit/extensions/HelperMacros.h>

#include <cppunit/extensions/TestFactoryRegistry.h>

void setUp() {

eventLoop_ = new DummyEventLoop();

boostIOServiceThread_ = new BoostIOServiceThread();

disconnected_ = false;

connectFinished_ = false;

}

connection->write(createSafeByteArray("\r\n\r\n")); // Temporarily, while we don't have an xmpp server running on ipv6

}

append(receivedData_, *data);

}

private:

BoostIOServiceThread* boostIOServiceThread_;

DummyEventLoop* eventLoop_;

ByteArray receivedData_;

bool disconnected_;

void setUp() {

ioServiceThread = new BoostIOServiceThread();

eventLoop = new DummyEventLoop();

#ifdef USE_UNBOUND

resolver = new UnboundDomainNameResolver(idnConverter.get(), ioServiceThread->getIOService(), eventLoop);

#else

}

void testResolveAddress() {

query->run();

waitForResults();

}

void testResolveAddress_Error() {

query->run();

waitForResults();

}

void testResolveAddress_IPv6() {

query->run();

waitForResults();

}

void testResolveAddress_IPv4and6() {

query->run();

waitForResults();

}

void testResolveAddress_International() {

query->run();

waitForResults();

}

void testResolveAddress_Localhost() {

query->run();

waitForResults();

}

void testResolveService() {

query->run();

waitForResults();

}

private:

result->onResult.connect(boost::bind(&DomainNameResolverTest::handleAddressQueryResult, this, _1, _2));

return result;

}

resultsAvailable = true;

}

result->onResult.connect(boost::bind(&DomainNameResolverTest::handleServiceQueryResult, this, _1));

return result;

}

private:

BoostIOServiceThread* ioServiceThread;

DummyEventLoop* eventLoop;

bool resultsAvailable;

std::vector<HostAddress> addressQueryResult;

std::vector<HostAddress> allAddressQueryResults;

SimpleEventLoop eventLoop_;

int count = 0;

std::cout << "Count " << count++ << std::endl;

if (timer) {

timer->stop();

int delay = 500;

// int delay = 0;

newTimer->onTick.connect(boost::bind(&handleTick, timer));

newTimer->start();

}

std::string pass(passChars);

client_ = new Swift::Client(jid, pass);

eventLoop_.run();

delete client_;

}

void testRead() {

CPPUNIT_ASSERT(createByteArray("/*\n * Copy") == *result.get());

}

void testRead_Twice() {

testling->read(10);

CPPUNIT_ASSERT_EQUAL(std::string("right (c) "), byteArrayToString(*result));

}

void testIsFinished_NotFinished() {

testling->read(10);

}

void testIsFinished_IsFinished() {

testling->read(4096);

void testSuccessfulWrite() {

boost::filesystem::path filename = boost::filesystem::unique_path("write_file_bytestream_test_%%%%%%%%%%%%%%%%.bin");

writeBytestream->onWrite.connect(boost::bind(&FileWriteBytestreamTest::handleOnWrite, this, _1));

CPPUNIT_ASSERT_EQUAL(true, writeBytestream->write(createByteArray("Some data.")));

}

void testFailingWrite() {

writeBytestream->onWrite.connect(boost::bind(&FileWriteBytestreamTest::handleOnWrite, this, _1));

CPPUNIT_ASSERT_EQUAL(false, writeBytestream->write(createByteArray("Some data.")));

}

void testSetVCard() {

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

vcard->setFullName("Alice In Wonderland");

}

void testGetVCard() {

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

vcard->setFullName("Alice In Wonderland");

testling->setVCard(JID("alice@wonderland.lit"), vcard);

}

void testGetVCard_FileDoesNotExist() {

VCard::ref result = testling->getVCard(JID("alice@wonderland.lit"));

CPPUNIT_ASSERT(!result);

}

void setUp() {

eventLoop_ = new DummyEventLoop();

boostIOServiceThread_ = new BoostIOServiceThread();

connectionFactory_ = new BoostConnectionFactory(boostIOServiceThread_->getIOService(), eventLoop_);

idnConverter_ = PlatformIDNConverter::create();

domainNameResolver_ = new PlatformDomainNameResolver(idnConverter_, eventLoop_);

}

HostAddress resolveName(const std::string& name) {

query->onResult.connect(boost::bind(&CertificateErrorTest::handleAddressQueryResult, this, _1, _2));

lastResoverResult_ = HostAddress();

resolvingDone_ = false;

return lastResoverResult_;

}

connection->onConnectFinished.connect(boost::bind(&CertificateErrorTest::handleConnectFinished, this, _1));

HostAddress address = resolveName(hostname);

}

void testTLS_O_MaticTrusted() {

TLSContext* context = connection->getTLSContext();

connectToServer(connection, "test1.tls-o-matic.com", 443);

}

void testTLS_O_MaticCertificateFromTheFuture() {

TLSContext* context = connection->getTLSContext();

connectToServer(connection, "test5.tls-o-matic.com", 405);

}

void testTLS_O_MaticCertificateFromThePast() {

TLSContext* context = connection->getTLSContext();

connectToServer(connection, "test6.tls-o-matic.com", 406);

}

void testTLS_O_MaticCertificateFromUnknownCA() {

TLSContext* context = connection->getTLSContext();

connectToServer(connection, "test7.tls-o-matic.com", 407);

// test14.tls-o-matic.com:414

void testTLS_O_MaticCertificateWrongPurpose() {

TLSContext* context = connection->getTLSContext();

connectToServer(connection, "test14.tls-o-matic.com", 414);

void testRevokedCertificateRevocationDisabled() {

tlsContextFactory_->setCheckCertificateRevocation(false);

TLSContext* context = connection->getTLSContext();

connectToServer(connection, "revoked.grc.com", 443);

void testRevokedCertificateRevocationEnabled() {

tlsContextFactory_->setCheckCertificateRevocation(true);

TLSContext* context = connection->getTLSContext();

connectToServer(connection, "revoked.grc.com", 443);

private:

BoostIOServiceThread* boostIOServiceThread_;

DummyEventLoop* eventLoop_;

ConnectionFactory* connectionFactory_;

PlatformTLSFactories* tlsFactories_;