#include <boost/asio.hpp>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include "Swiften/Elements/IQ.h"

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Base/IDGenerator.h"

#include "Swiften/EventLoop/MainEventLoop.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "Swiften/Elements/Stanza.h"

#include "Swiften/Network/ConnectionServer.h"

#include "Swiften/Network/BoostConnection.h"

using namespace Swift;

public:

BoostConnectionServer(int port, boost::asio::io_service& ioService) : acceptor_(ioService, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)) {

acceptNextConnection();

}

void acceptNextConnection() {

boost::shared_ptr<BoostConnection> newConnection(new BoostConnection(&acceptor_.io_service()));

acceptor_.async_accept(newConnection->getSocket(),

}

void handleAccept(boost::shared_ptr<BoostConnection> newConnection, const boost::system::error_code& error) {

if (!error) {

newConnection->listen();

acceptNextConnection();

}

class Server {

public:

Server(UserRegistry* userRegistry) : userRegistry_(userRegistry) {

serverFromClientConnectionServer_->onNewConnection.connect(boost::bind(&Server::handleNewConnection, this, _1));

}

private:

IDGenerator idGenerator_;

UserRegistry* userRegistry_;

BoostIOServiceThread boostIOServiceThread_;

std::vector<ServerFromClientSession*> serverFromClientSessions_;

FullPayloadParserFactoryCollection payloadParserFactories_;

FullPayloadSerializerCollection payloadSerializers_;

int main() {

SimpleEventLoop eventLoop;

SimpleUserRegistry userRegistry;

Server server(&userRegistry);

eventLoop.run();

return 0;

payloadSerializers_(payloadSerializers),

state_(Initial),

error_(NoError),

streamStack_(0),

needSessionStart_(false) {

}

Session::~Session() {

delete streamStack_;

}

void Session::start() {

}

void Session::initializeStreamStack() {

xmppLayer_->onStreamStart.connect(boost::bind(&Session::handleStreamStart, this));

xmppLayer_->onElement.connect(boost::bind(&Session::handleElement, this, _1));

xmppLayer_->onError.connect(boost::bind(&Session::setError, this, XMLError));

xmppLayer_->onDataRead.connect(boost::bind(boost::ref(onDataRead), _1));

xmppLayer_->onWriteData.connect(boost::bind(boost::ref(onDataWritten), _1));

streamStack_ = new StreamStack(xmppLayer_, connectionLayer_);

}

// Start the session

// Add a whitespace ping layer

streamStack_->addLayer(whitespacePingLayer_);

if (streamFeatures->hasSession()) {

State state_;

SessionError error_;

boost::shared_ptr<Connection> connection_;

StreamStack* streamStack_;

bool needSessionStart_;

PKCS12Certificate certificate_;

MockTLSLayerFactory() : haveTLS_(true) {}

void setTLSSupported(bool b) { haveTLS_ = b; }

virtual bool canCreate() const { return haveTLS_; }

assert(haveTLS_);

layers_.push_back(result);

return result;

}

bool haveTLS_;

};

struct MockSession : public Session {

MockSession(const JID& jid, ConnectionFactory* connectionFactory, TLSLayerFactory* tlsLayerFactory, PayloadParserFactoryCollection* payloadParserFactories, PayloadSerializerCollection* payloadSerializers) : Session(jid, connectionFactory, tlsLayerFactory, payloadParserFactories, payloadSerializers) {}

return getStreamStack()->getLayer<MockTLSLayer>();

}

return getStreamStack()->getLayer<WhitespacePingLayer>();

}

};

* If the owner is destroyed, all events should be removed from the

* loop using removeEventsFromOwner().

*/

static void removeEventsFromOwner(boost::shared_ptr<EventOwner> owner);

#include <boost/thread.hpp>

#include <boost/bind.hpp>

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "Swiften/Base/sleep.h"

void testPost() {

SimpleEventLoop testling;

testling.stop();

testling.run();

void testRemove() {

SimpleEventLoop testling;

testling.stop();

testling.run();

}

private:

void logEvent(int i) {

events_.push_back(i);

}

void testPostFromMainThread() {

SimpleEventLoop testling;

testling.run();

CPPUNIT_ASSERT_EQUAL(1, counter_);

void runIncrementingThread(SimpleEventLoop* loop) {

for (unsigned int i = 0; i < 10; ++i) {

Swift::sleep(1);

}

loop->stop();

}

}

BoostConnection::~BoostConnection() {

}

void BoostConnection::listen() {

}

void BoostConnection::disconnect() {

socket_.close();

}

}

Timer::~Timer() {

ioService_->stop();

thread_->join();

delete timer_;

{

boost::shared_ptr<Timer> timer(new Timer(10000));

eventLoop.run();

}

BoostConnectionTest() {}

void setUp() {

boostIOServiceThread_ = new BoostIOServiceThread();

}

void tearDown() {

delete eventLoop_;

}

void testDestructor() {

userRegistry_(userRegistry),

authenticated_(false),

initialized_(false) {

xmppLayer_->onStreamStart.connect(

boost::bind(&ServerFromClientSession::handleStreamStart, this, _2));

xmppLayer_->onElement.connect(

boost::bind(boost::ref(onDataRead), _1));

xmppLayer_->onWriteData.connect(

boost::bind(boost::ref(onDataWritten), _1));

streamStack_ = new StreamStack(xmppLayer_, connectionLayer_);

}

ServerFromClientSession::~ServerFromClientSession() {

delete streamStack_;

}

void ServerFromClientSession::handleElement(boost::shared_ptr<Element> element) {

UserRegistry* userRegistry_;

bool authenticated_;

bool initialized_;

StreamStack* streamStack_;

JID domain_;

String user_;

JID jid_;

#endif

}

#ifdef HAVE_OPENSSL

#else

assert(false);

#endif

}

#include "Swiften/StreamStack/TLSLayerFactory.h"

PlatformTLSLayerFactory();

bool canCreate() const;

};

}

#include <boost/bind.hpp>

#include "Swiften/StreamStack/XMPPLayer.h"

#include "Swiften/StreamStack/LowLayer.h"

#include "Swiften/StreamStack/StreamLayer.h"

namespace Swift {

xmppReadSlotConnection_ = physicalLayer_->onDataRead.connect(boost::bind(&XMPPLayer::parseData, xmppLayer_, _1));

xmppWriteSignalConnection_ = xmppLayer_->onWriteData.connect(boost::bind(&LowLayer::writeData, physicalLayer_, _1));

}

xmppReadSlotConnection_.disconnect();

xmppWriteSignalConnection_.disconnect();

lowLayer->onDataRead.connect(boost::bind(&HighLayer::handleDataRead, newLayer, _1), boost::bsignals::at_front);

xmppWriteSignalConnection_ = xmppLayer_->onWriteData.connect(boost::bind(&LowLayer::writeData, newLayer, _1), boost::bsignals::at_front);

xmppReadSlotConnection_ = newLayer->onDataRead.connect(boost::bind(&XMPPLayer::parseData, xmppLayer_, _1), boost::bsignals::at_front);

layers_.push_back(newLayer);

#include <boost/shared_ptr.hpp>

#include <boost/signal.hpp>

class StreamStack {

public:

return xmppLayer_;

}

if (layer) {

return layer;

}

}

}

private:

boost::bsignals::connection xmppReadSlotConnection_;

boost::bsignals::connection xmppWriteSignalConnection_;

};

}

namespace Swift {

class TLSLayer;

virtual ~TLSLayerFactory();

virtual bool canCreate() const = 0;

};

}

StreamStackTest() {}

void setUp() {

elementsReceived_ = 0;

dataWriteReceived_ = 0;

}

void tearDown() {

}

void testWriteData_NoIntermediateStreamStack() {

void testWriteData_OneIntermediateStream() {

StreamStack testling(xmppStream_, physicalStream_);

xmppStream_->writeData("foo");

void testWriteData_TwoIntermediateStreamStack() {

StreamStack testling(xmppStream_, physicalStream_);

xmppStream_->writeData("foo");

void testReadData_OneIntermediateStream() {

StreamStack testling(xmppStream_, physicalStream_);

xmppStream_->onElement.connect(boost::bind(&StreamStackTest::handleElement, this, _1));

physicalStream_->onDataRead(ByteArray("stream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));

void testReadData_TwoIntermediateStreamStack() {

StreamStack testling(xmppStream_, physicalStream_);

xmppStream_->onElement.connect(boost::bind(&StreamStackTest::handleElement, this, _1));

physicalStream_->onDataRead(ByteArray("tream:stream xmlns:stream='http://etherx.jabber.org/streams'><presence/>"));

void testAddLayer_ExistingOnWriteDataSlot() {

StreamStack testling(xmppStream_, physicalStream_);

xmppStream_->onWriteData.connect(boost::bind(&StreamStackTest::handleWriteData, this, _1));

xmppStream_->writeData("foo");

private:

FullPayloadParserFactoryCollection parserFactories_;

FullPayloadSerializerCollection serializers_;

int elementsReceived_;

int dataWriteReceived_;

};