myenv.Append(CFLAGS = ["-x", "c++"])

# Remove warn flags

myenv.MergeFlags(myenv["LUA_FLAGS"])

myenv.StaticLibrary("Swiften_Lua", [

"src/lapi.c",

if "clang" in env["CXX"] :

env.Append(CXXFLAGS = [

"-Weverything",

"-Wno-sign-conversion", # We have this a lot. Not sure if we should allow this or not.

"-Wno-weak-vtables", # Virtually none of our elements have outlined methods

"-Wno-shadow", # Also warns for shadowing on constructor arguments, which we do a lot

using namespace Swift;

using namespace boost;

void handleConnected();

void handleMessageReceived(Message::ref message);

* Helper classes

******************************************************************************/

class SluiftClient {

CPPUNIT_TEST_SUITE_END();

public:

LastLineTrackerTest () {

void testFocusNormal() {

LastLineTracker testling;

testling.setHasFocus(true);

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

completer_ = TabComplete();

void replaceMessage(const std::string& message, const std::string& id, const boost::posix_time::ptime& time);

virtual void setOnline(bool online);

virtual void setEnabled(bool enabled);

/** Used for determining when something is recent.*/

boost::signal<void (const std::string& /*activity*/)> onActivity;

boost::signal<void ()> onUnreadCountChanged;

/**

* Pass the Message appended, and the stanza used to send it.

*/

virtual std::string senderDisplayNameFromMessage(const JID& from) = 0;

virtual bool isIncomingMessageFromMe(boost::shared_ptr<Message>) = 0;

virtual bool isFromContact(const JID& from);

virtual boost::optional<boost::posix_time::ptime> getMessageTimestamp(boost::shared_ptr<Message>) const = 0;

virtual void handleBareJIDCapsChanged(const JID& jid) = 0;

std::string getErrorMessage(boost::shared_ptr<ErrorPayload>);

virtual void setContactIsReceivingPresence(bool /* isReceivingPresence */) {}

enum JoinPart {Join, Part, JoinThenPart, PartThenJoin};

struct NickJoinPart {

std::string nick;

JoinPart type;

};

manager_ = new ChatsManager(jid_, stanzaChannel_, iqRouter_, eventController_, chatWindowFactory_, joinMUCWindowFactory_, nickResolver_, presenceOracle_, directedPresenceSender_, uiEventStream_, chatListWindowFactory_, true, NULL, mucRegistry_, entityCapsManager_, mucManager_, mucSearchWindowFactory_, profileSettings_, ftOverview_, xmppRoster_, false, settings_, NULL, wbManager_);

manager_->setAvatarManager(avatarManager_);

void tearDown() {

//delete chatListWindowFactory

muc_ = boost::make_shared<MUC>(stanzaChannel_, iqRouter_, directedPresenceSender_, mucJID_, mucRegistry_);

mocks_->ExpectCall(chatWindowFactory_, ChatWindowFactory::createChatWindow).With(muc_->getJID(), uiEventStream_).Return(window_);

controller_ = new MUCController (self_, muc_, boost::optional<std::string>(), nick_, stanzaChannel_, iqRouter_, chatWindowFactory_, presenceOracle_, avatarManager_, uiEventStream_, false, timerFactory, eventController_, entityCapsProvider_, NULL, NULL, mucRegistry_);

void tearDown() {

delete entityCapsProvider_;

class MockChatListWindow : public ChatListWindow {

public:

void addMUCBookmark(const MUCBookmark& /*bookmark*/) {}

void removeMUCBookmark(const MUCBookmark& /*bookmark*/) {}

void setBookmarksEnabled(bool /*enabled*/) {}

void setRecents(const std::list<ChatListWindow::Chat>& /*recents*/) {}

void setUnreadCount(int /*unread*/) {}

namespace Swift {

class DummySoundPlayer : public SoundPlayer {

public:

};

}

namespace Swift {

class DummySystemTray : public SystemTray {

public:

void setConnecting() {}

};

}

void applyOnItems(const RosterItemOperation& operation);

void applyOnAllItems(const RosterItemOperation& operation);

void applyOnItem(const RosterItemOperation& operation, const JID& jid);

void removeFilter(RosterFilter *filter);

GroupRosterItem* getRoot();

boost::signal<void (GroupRosterItem*)> onChildrenChanged;

boost::signal<void (GroupRosterItem*)> onGroupAdded;

boost::signal<void (RosterItem*)> onDataChanged;

RosterController(const JID& jid, XMPPRoster* xmppRoster, AvatarManager* avatarManager, MainWindowFactory* mainWindowFactory, NickManager* nickManager, NickResolver* nickResolver, PresenceOracle* presenceOracle, SubscriptionManager* subscriptionManager, EventController* eventController, UIEventStream* uiEventStream, IQRouter* iqRouter_, SettingsProvider* settings, EntityCapsProvider* entityCapsProvider, FileTransferOverview* fileTransferOverview);

~RosterController();

void showRosterWindow();

boost::signal<void (StatusShow::Type, const std::string&)> onChangeStatusRequest;

boost::signal<void ()> onSignOutRequest;

void handleAvatarChanged(const JID& jid);

class RosterItemOperation {

public:

/**

* This is called when iterating over possible subjects, so must check it's

* applying to the right items - even if requiresLookup() is true an item

ftOverview_ = new FileTransferOverview(ftManager_);

rosterController_ = new RosterController(jid_, xmppRoster_, avatarManager_, mainWindowFactory_, nickManager_, nickResolver_, presenceOracle_, subscriptionManager_, eventController_, uiEventStream_, router_, settings_, entityCapsManager_, ftOverview_);

mainWindow_ = mainWindowFactory_->last;

void tearDown() {

delete rosterController_;

delete uiEventStream_;

delete settings_;

delete xmppRoster_;

GroupRosterItem* groupChild(size_t i) {

return dynamic_cast<GroupRosterItem*>(CHILDREN[i]);

CPPUNIT_ASSERT(item2);

CPPUNIT_ASSERT_EQUAL(presence->getStatus(), item2->getStatusText());

void testHighestPresence() {

std::vector<std::string> groups;

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

CPPUNIT_ASSERT_EQUAL(highPresence->getStatus(), item->getStatusText());

void testNotHighestPresence() {

std::vector<std::string> groups;

ContactRosterItem* item = dynamic_cast<ContactRosterItem*>(dynamic_cast<GroupRosterItem*>(CHILDREN[0])->getChildren()[0]);

CPPUNIT_ASSERT(item);

CPPUNIT_ASSERT_EQUAL(highPresence->getStatus(), item->getStatusText());

void testUnavailablePresence() {

std::vector<std::string> groups;

CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), high->getStatus());

CPPUNIT_ASSERT_EQUAL(StatusShow::None, item->getStatusShow());

CPPUNIT_ASSERT_EQUAL(lowPresenceOffline->getStatus(), item->getStatusText());

void testAdd() {

std::vector<std::string> groups;

CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(CHILDREN.size()));

//CPPUNIT_ASSERT_EQUAL(std::string("Bob"), xmppRoster_->getNameForJID(JID("foo@bar.com")));

void testAddSubscription() {

std::vector<std::string> groups;

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

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(groupChild(0)->getChildren().size()));

void testReceiveRename() {

std::vector<std::string> groups;

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

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(groupChild(0)->getChildren().size()));

CPPUNIT_ASSERT_EQUAL(std::string("NewName"), groupChild(0)->getChildren()[0]->getDisplayName());

void testReceiveRegroup() {

std::vector<std::string> oldGroups;

CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(groupChild(0)->getChildren().size()));

CPPUNIT_ASSERT_EQUAL(std::string("new name"), groupChild(0)->getChildren()[0]->getDisplayName());

CPPUNIT_ASSERT_EQUAL(std::string("Best Group"), groupChild(0)->getDisplayName());

void testSendRename() {

JID jid("testling@wonderland.lit");

virtual ~DummySettingsProvider() {}

virtual std::string getSetting(const Setting<std::string>& setting) {

return stringValues.find(setting.getKey()) != stringValues.end() ? stringValues[setting.getKey()] : setting.getDefaultValue();

virtual void storeSetting(const Setting<std::string>& setting, const std::string& value) {

stringValues[setting.getKey()] = value;

onSettingChanged(setting.getKey());

virtual bool getSetting(const Setting<bool>& setting) {

return boolValues.find(setting.getKey()) != boolValues.end() ? boolValues[setting.getKey()] : setting.getDefaultValue();

virtual void storeSetting(const Setting<bool>& setting, const bool& value) {

boolValues[setting.getKey()] = value;

onSettingChanged(setting.getKey());

virtual int getSetting(const Setting<int>& setting) {

return intValues.find(setting.getKey()) != intValues.end() ? intValues[setting.getKey()] : setting.getDefaultValue();

virtual void storeSetting(const Setting<int>& setting, const int& value) {

intValues[setting.getKey()] = value;

onSettingChanged(setting.getKey());

virtual std::vector<std::string> getAvailableProfiles() {return std::vector<std::string>();}

virtual void createProfile(const std::string& ) {}

virtual void removeProfile(const std::string& ) {}

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

bottom = new DummySettingsProvider();

public:

SoundEventController(EventController* eventController, SoundPlayer* soundPlayer, SettingsProvider* settings);

void setPlaySounds(bool playSounds);

private:

void handleSettingChanged(const std::string& settingPath);

void handleEventQueueEventAdded(boost::shared_ptr<StanzaEvent> event);

namespace Swift {

class SoundPlayer {

public:

enum SoundEffect{MessageReceived};

virtual void playSound(SoundEffect sound) = 0;

};

namespace Swift {

class SystemTray {

public:

virtual void setUnreadMessages(bool some) = 0;

virtual void setStatusType(StatusShow::Type type) = 0;

virtual void setConnecting() = 0;

namespace Swift {

virtual std::string translate(const std::string& text, const std::string&) {

return text;

}

namespace Swift {

class AddContactUIEvent : public UIEvent {

public:

const std::string& getName() const {

return name_;

const JID& getJID() const {

return jid_;

const std::set<std::string>& getGroups() const {

return groups_;

namespace Swift {

class AddMUCBookmarkUIEvent : public UIEvent {

public:

const MUCBookmark& getBookmark() { return bookmark; }

private:

namespace Swift {

class EditMUCBookmarkUIEvent : public UIEvent {

public:

private:

MUCBookmark oldBookmark;

class JoinMUCUIEvent : public UIEvent {

public:

typedef boost::shared_ptr<JoinMUCUIEvent> ref;

const boost::optional<std::string>& getNick() const {return nick_;}

const JID& getJID() const {return jid_;}

bool getShouldJoinAutomatically() const {return joinAutomatically_;}

namespace Swift {

class RemoveMUCBookmarkUIEvent : public UIEvent {

public:

const MUCBookmark& getBookmark() { return bookmark; }

private:

class RemoveRosterItemUIEvent : public UIEvent {

public:

private:

JID jid_;

namespace Swift {

class RequestAdHocUIEvent : public UIEvent {

public:

const DiscoItems::Item& getCommand() const {return command_;}

private:

DiscoItems::Item command_;

class RequestAddUserDialogUIEvent : public UIEvent {

public:

private:

JID preJID_;

namespace Swift {

class RequestChatUIEvent : public UIEvent {

public:

JID getContact() {return contact_;}

private:

JID contact_;

namespace Swift {

class RequestWhiteboardUIEvent : public UIEvent {

public:

const JID& getContact() const {return contact_;}

private:

JID contact_;

namespace Swift {

class ShowWhiteboardUIEvent : public UIEvent {

public:

const JID& getContact() const {return contact_;}

private:

JID contact_;

void send(boost::shared_ptr<UIEvent> event) {

onUIEvent(event);

};

}

namespace Swift {

class AdHocCommandWindow {

public:

};

}

bool operator==(const Chat& other) const {

return jid.toBare() == other.jid.toBare()

&& isMUC == other.isMUC;

void setUnreadCount(int unread) {

unreadCount = unread;

}

enum FileTransferState {WaitingForAccept, Negotiating, Transferring, Canceled, Finished, FTFailed};

enum WhiteboardSessionState {WhiteboardAccepted, WhiteboardTerminated, WhiteboardRejected};

ChatWindow() {}

/** Add message to window.

* @return id of added message (for acks).

class UIEventStream;

class ChatWindowFactory {

public:

/**

* Transfers ownership of result.

*/

namespace Swift {

class ContactEditWindowFactory {

public:

virtual ContactEditWindow* createContactEditWindow() = 0;

};

return canDelete_;

}

virtual void addEvent(boost::shared_ptr<StanzaEvent> event, bool active) = 0;

virtual void removeEvent(boost::shared_ptr<StanzaEvent> event) = 0;

class EventWindowFactory {

public:

/**

* Transfers ownership of result.

*/

namespace Swift {

class HistoryWindow {

public:

virtual void activate() = 0;

virtual void setRosterModel(Roster*) = 0;

class UIEventStream;

class HistoryWindowFactory {

public:

virtual HistoryWindow* createHistoryWindow(UIEventStream* eventStream) = 0;

};

}

namespace Swift {

class InviteToChatWindow {

public:

virtual void setAutoCompletions(std::vector<std::pair<JID, std::string> > completions) = 0;

namespace Swift {

class JoinMUCWindow {

public:

virtual void setNick(const std::string& nick) = 0;

virtual void setMUC(const std::string& nick) = 0;

class UIEventStream;

class JoinMUCWindowFactory {

public:

virtual JoinMUCWindow* createJoinMUCWindow(UIEventStream* uiEventStream) = 0;

};

class MainWindow;

class LoginWindow {

public:

virtual void selectUser(const std::string&) = 0;

virtual void morphInto(MainWindow *mainWindow) = 0;

virtual void loggedOut() = 0;

class LoginWindowFactory {

public:

/**

* Transfers ownership of result.

class MUCSearchWindow {

public:

virtual void clearList() = 0;

virtual void addService(const MUCService& service) = 0;

class UIEventStream;

class MUCSearchWindowFactory {

public:

virtual MUCSearchWindow* createMUCSearchWindow() = 0;

};

class MainWindow {

public:

MainWindow(bool candelete = true) : canDelete_(candelete) {}

bool canDelete() const {

return canDelete_;

class MainWindowFactory {

public:

/**

* Transfers ownership of result.

*/

namespace Swift {

class ProfileWindow {

public:

virtual void setVCard(VCard::ref vcard) = 0;

namespace Swift {

class ProfileWindowFactory {

public:

virtual ProfileWindow* createProfileWindow() = 0;

};

class UIEventStream;

class UserSearchWindowFactory {

public:

virtual UserSearchWindow* createUserSearchWindow(UserSearchWindow::Type type, UIEventStream* eventStream, const std::set<std::string>& groups) = 0;

};

class WhiteboardWindowFactory {

public :

virtual WhiteboardWindow* createWhiteboardWindow(boost::shared_ptr<WhiteboardSession> whiteboardSession) = 0;

};

class UIEventStream;

class XMLConsoleWidgetFactory {

public:

virtual XMLConsoleWidget* createXMLConsoleWidget() = 0;

};

CPPUNIT_TEST_SUITE_END();

public:

void setUp() {

namespace Swift {

class MockChatWindow : public ChatWindow {

public:

virtual ~MockChatWindow();

// File transfer related stuff

virtual void setMessageReceiptState(const std::string &/* id */, ReceiptState /* state */) { }

virtual SecurityLabelsCatalog::Item getSelectedSecurityLabel() {return label_;}

virtual void setCorrectionEnabled(Tristate /*enabled*/) {}

void setAvailableOccupantActions(const std::vector<OccupantAction>&/* actions*/) {}

void setSubject(const std::string& /*subject*/) {}

virtual void showRoomConfigurationForm(Form::ref) {}

virtual void setAffiliations(MUCOccupant::Affiliation, const std::vector<JID>&) {}

virtual InviteToChatWindow* createInviteToChatWindow() {return NULL;}

std::string name_;

class MockMainWindowFactory : public MainWindowFactory {

public:

/**

* Transfers ownership of result.

*/

MockMainWindow* last;

};

}

namespace Swift {

class ErrorEvent : public StanzaEvent {

public:

private:

JID jid_;

public:

typedef boost::shared_ptr<MessageEvent> ref;

boost::shared_ptr<Message> getStanza() {return stanza_;}

namespace Swift {

class StanzaEvent {

public:

/** Do not call this directly from outside the class.

* If you connect to this signal, you *must* disconnect from it manually. */

boost::signal<void()> onConclusion;

boost::posix_time::ptime getTime() {return time_;}

private:

bool concluded_;

namespace Swift {

class SubscriptionRequestEvent : public StanzaEvent {

public:

boost::signal<void()> onAccept;

boost::signal<void()> onDecline;

void accept() {

onAccept();

conclude();

void decline() {

onDecline();

conclude();

void defer() {

conclude();

namespace Swift {

class ChatListGroupItem : public ChatListItem {

public:

private:

static bool pointerItemLessThan(const ChatListItem* first, const ChatListItem* second) {

QString myName = first->data(Qt::DisplayRole).toString().toLower();

class ChatListGroupItem;

class ChatListItem {

public:

virtual ~ChatListItem() {}

virtual QVariant data(int role) const = 0;

private:

public:

QtEvent(boost::shared_ptr<StanzaEvent> event, bool active);

QVariant data(int role);

enum EventRoles {

SenderRole = Qt::UserRole

QString getContinuationElementID() const {

return "insert";

private:

QString content_;

class QtChatTheme {

public:

QtChatTheme(const QString& themePath);

QString getTemplate() const {return fileContents_[Template];}

QString getMainCSS() const {return fileContents_[MainCSS];}

QString getBase() const;

enum AlertType {NoActivity, WaitingActivity, ImpendingActivity};

~QtTabbable();

bool isWidgetSelected();

virtual int getCount() {return 0;}

protected:

void keyPressEvent(QKeyEvent* event);

protected slots:

# Disable warnings that affect Qt

myenv["CXXFLAGS"] = filter(lambda x : x != "-Wfloat-equal", myenv["CXXFLAGS"])

if "clang" in env["CC"] :

myenv.UseFlags(env["SWIFT_CONTROLLERS_FLAGS"])

myenv.UseFlags(env["SWIFTOOLS_FLAGS"])

/**

* Called before onConnected signal is emmitted.

*/

private:

void handleConnectorFinished(boost::shared_ptr<Connection>, boost::shared_ptr<Error> error);

return input.replace(env.Dir("#").abspath, "#")

def cStringVariable(env, cVar, sconsVar) :

# FIXME: Probably not very robust

for var in sconsVar.split(" ") :

result += "\t\"" + env.subst(var).replace("\\", "\\\\") + "\",\n"

struct Note {

enum Type {Info, Warn, Error};

std::string note;

Type type;

namespace Swift {

class Delay : public Payload {

public:

private:

boost::posix_time::ptime time_;

namespace Swift {

class Last : public Payload {

public:

int getSeconds() const {return seconds_;}

void setSeconds(int seconds) {seconds_ = seconds;}

class Replace : public Payload {

public:

typedef boost::shared_ptr<Replace> ref;

const std::string& getID() const {

return replaceID_;

}

public:

typedef boost::shared_ptr<WhiteboardOperation> ref;

public:

std::string getID() const {

return id_;

using namespace Swift;

static void handleConnected() {

enum ExitCodes {OK = 0, CANNOT_CONNECT, CANNOT_AUTH, NO_RESPONSE, DISCO_ERROR};

static void handleServerDiscoInfoResponse(boost::shared_ptr<DiscoInfo> /*info*/, ErrorPayload::ref error) {

if (!error) {

using namespace Swift;

static void handleGetPublicIPRequestResponse(const boost::optional<HostAddress>& result) {

if (result) {

using namespace Swift;

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

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

using namespace Swift;

class FileSender {

public:

using namespace Swift;

static void handleConnected() {

using namespace Swift;

class SOCKS5BytestreamClientSessionTest : public CppUnit::TestFixture {

CPPUNIT_TEST_SUITE(SOCKS5BytestreamClientSessionTest);

* Messages are stored using localtime timestamps.

*/

public:

virtual void addMessage(const HistoryMessage& message) = 0;

virtual std::vector<HistoryMessage> getMessagesFromDate(const JID& selfJID, const JID& contactJID, HistoryMessage::Type type, const boost::gregorian::date& date) const = 0;

header << ":" << *boshURL.getPort();

}

header << "\r\n"

<< "Content-Type: text/xml; charset=utf-8\r\n"

<< "Content-Length: " << size << "\r\n\r\n";

<< " rid='" << rid << "'"

<< " ver='1.6'"

<< " wait='60'" /* FIXME: we probably want this configurable*/

<< " xml:lang='en'"

<< " xmlns:xmpp='urn:xmpp:bosh'"

<< " xmpp:version='1.0'"

header << ":" << *boshURL_.getPort();

}

header << "\r\n"

<< "Content-Type: text/xml; charset=utf-8\r\n"

<< "Content-Length: " << contentString.size() << "\r\n\r\n"

<< contentString;

TLSConnection(Connection::ref connection, TLSContextFactory* tlsFactory);

virtual ~TLSConnection();

virtual void connect(const HostAddressPort& address);

virtual void disconnect();

virtual void write(const SafeByteArray& data);

#include <iostream>

#include <string>

#include <expat.h>

#include <Swiften/Base/String.h>

#include <Swiften/Parser/XMLParserClient.h>

namespace Swift {

static const char NAMESPACE_SEPARATOR = '\x01';

}

bool ExpatParser::parse(const std::string& data) {

/*if (!success) {

std::cout << "ERROR: " << XML_ErrorString(XML_GetErrorCode(p->parser_)) << " while parsing " << data << std::endl;

}*/

using namespace Swift;

enum TestStage {

FirstConnect,

Reconnect

};

static void handleDisconnected(boost::optional<ClientError> e) {

std::cout << "Disconnected: " << e << std::endl;

#include <Swiften/Network/BoostIOServiceThread.h>

#include <Swiften/EventLoop/DummyEventLoop.h>

using namespace Swift;