libtransport.git Changeset - 99e958e8c83a

Changeset - 99e958e8c83a

Parent rev.

Child rev.

[Not reviewed]

0 2 0

Jan Kaluza - 9 years ago 2016-02-18 07:34:59
jkaluza@redhat.com

Libtransport: Send self presence as first one when joining from second resource

2 files changed with 13 insertions and 13 deletions:

libtransport/Conversation.cpp

tests/libtransport/user.cpp

0 comments (0 inline, 0 general)

libtransport/Conversation.cpp

➞

Show inline comments

@@ @@ -62,370 +62,370 @@ void Conversation::setMUCEscaping(bool mucEscaping) { @@
 	m_mucEscaping = mucEscaping;
+}
 void Conversation::destroyRoom() {
 	if (m_muc) {
 		Swift::Presence::ref presence = Swift::Presence::create();
 		std::string legacyName = m_legacyName;
 		if (!m_mucEscaping && legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		legacyName = Swift::JID::getEscapedNode(legacyName);
 		presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), m_nickname));
 		presence->setType(Swift::Presence::Unavailable);
 		Swift::MUCItem item;
 		item.affiliation = Swift::MUCOccupant::NoAffiliation;
 		item.role = Swift::MUCOccupant::NoRole;
 		item.actor = "Transport";
 		item.reason = "Spectrum 2 transport is being shut down.";
 		Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 		p->addItem(item);
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 332;
 		p->addStatusCode(c);
 		Swift::MUCUserPayload::StatusCode c2;
 		c2.code = 307;
 		p->addStatusCode(c2);
 		presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
 		BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 			presence->setTo(jid);
 			m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
+		}
+	}
+}
 void Conversation::setRoom(const std::string &room) {
 	m_room = room;
 	m_legacyName = m_room + "/" + m_legacyName;
+}
 void Conversation::cacheMessage(boost::shared_ptr<Swift::Message> &message) {
 	boost::posix_time::ptime timestamp = boost::posix_time::second_clock::universal_time();
 	boost::shared_ptr<Swift::Delay> delay(boost::make_shared<Swift::Delay>());
 	delay->setStamp(timestamp);
 	message->addPayload(delay);
 	m_cachedMessages.push_back(message);
 	if (m_cachedMessages.size() > 100) {
 		m_cachedMessages.pop_front();
+	}
+}
 void Conversation::handleRawMessage(boost::shared_ptr<Swift::Message> &message) {
 	if (message->getType() != Swift::Message::Groupchat) {
 		if (m_conversationManager->getComponent()->inServerMode() && m_conversationManager->getUser()->shouldCacheMessages()) {
 			cacheMessage(message);
+		}
 		else {
 			m_conversationManager->getComponent()->getFrontend()->sendMessage(message);
+		}
+	}
 	else {
 		if (m_jids.empty()) {
 			cacheMessage(message);
+		}
 		else {
 			BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 				message->setTo(jid);
 				// Subject has to be sent after our own presence (the one with code 110)
 				if (!message->getSubject().empty()) {
 					m_subject = message;
 					if (m_sentInitialPresence == false) {
 						return;
+					}
+				}
 				m_conversationManager->getComponent()->getFrontend()->sendMessage(message);
+			}
+		}
+	}
+}
 void Conversation::handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname) {
 	if (m_muc) {
 		message->setType(Swift::Message::Groupchat);
+	}
 	else {
 		if (message->getType() == Swift::Message::Headline) {
 			if (m_conversationManager->getUser()->getUserSetting("send_headlines") != "1") {
 				message->setType(Swift::Message::Chat);
+			}
+		}
 		else {
 			message->setType(Swift::Message::Chat);
+		}
+	}
 	std::string n = nickname;
 	if (n.empty() && !m_room.empty() && !m_muc) {
 		n = m_nickname;
+	}
 	if (message->getType() != Swift::Message::Groupchat) {
 		message->setTo(m_jid);
 		// normal message
 		if (n.empty()) {
 			Buddy *buddy = m_conversationManager->getUser()->getRosterManager()->getBuddy(m_legacyName);
 			if (buddy) {
 				message->setFrom(buddy->getJID());
+			}
 			else {
 				std::string name = m_legacyName;
 				if (CONFIG_BOOL_DEFAULTED(m_conversationManager->getComponent()->getConfig(), "service.jid_escaping", true)) {
 					name = Swift::JID::getEscapedNode(m_legacyName);
+				}
 				else {
 					if (name.find_last_of("@") != std::string::npos) {
 						name.replace(name.find_last_of("@"), 1, "%");
+					}
+				}
 				message->setFrom(Swift::JID(name, m_conversationManager->getComponent()->getJID().toBare(), "bot"));
+			}
+		}
 		// PM message
 		else {
 			if (m_room.empty()) {
 				message->setFrom(Swift::JID(n, m_conversationManager->getComponent()->getJID().toBare(), "user"));
+			}
 			else {
 				std::string legacyName = m_room;
 				if (!m_mucEscaping && legacyName.find_last_of("@") != std::string::npos) {
 					legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+				}
 				legacyName = Swift::JID::getEscapedNode(legacyName);
 				message->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), n));
+			}
+		}
+	}
 	else {
 		std::string legacyName = m_legacyName;
 		if (!m_mucEscaping && legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		legacyName = Swift::JID::getEscapedNode(legacyName);
 		std::string n = nickname;
 		if (n.empty()) {
 			n = " ";
+		}
 		std::map<std::string, Participant>::iterator it = m_participants.find(n);
 		if (it != m_participants.end() && !it->second.alias.empty()) {
 			n = it->second.alias;
+		}
 		message->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), n));
 		LOG4CXX_INFO(logger, "MSG FROM " << message->getFrom().toString());
+	}
 	handleRawMessage(message);
+}
 std::string Conversation::getParticipants() {
 	std::string ret;
 	for (std::map<std::string, Participant>::iterator it = m_participants.begin(); it != m_participants.end(); it++) {
 		ret += (*it).second.presence->getFrom().getResource() + ", ";
+	}
 	return ret;
+}
 void Conversation::sendParticipants(const Swift::JID &to, const std::string &nickname) {
 	// When user tries to join this room from another resource using
 	// different nickname than the original one has, we have to rename
 	// him.
 	LOG4CXX_INFO(logger, m_jid.toString() << ": Sending participants to " << to.toString() << ", Nickname:" << nickname << ", Conversation nickname:" << m_nickname);
 	if (m_nickname != nickname && !nickname.empty()) {
 		Swift::Presence::ref presence;
 		std::string tmp = m_nickname;
 		// At first connect the user.
 		m_nickname = nickname;
 		presence = generatePresence(nickname, 0, (int) Swift::StatusShow::Online, "", "", "");
 		presence->setTo(to);
 		m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
 		// Now change his nickname to the right one.
 		m_nicknameChanged = true;
 		presence = generatePresence(nickname, 0, (int) Swift::StatusShow::Online, "", tmp, "");
 		presence->setTo(to);
 		m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
 		// And send the presence from as new user
 		m_nickname = tmp;
 		presence = generatePresence(m_nickname, 0, (int) Swift::StatusShow::Online, "", "", "");
 		presence->setTo(to);
 		m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
+	}
 	// Self presence has to be sent as first.
 	Swift::Presence::ref presence = generatePresence(m_nickname, 0, (int) Swift::StatusShow::Online, "", "", "");
 	presence->setTo(to);
 	m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
 	for (std::map<std::string, Participant>::iterator it = m_participants.begin(); it != m_participants.end(); it++) {
 		(*it).second.presence->setTo(to);
 		m_conversationManager->getComponent()->getFrontend()->sendPresence((*it).second.presence);
+	}
+}
 void Conversation::sendCachedMessages(const Swift::JID &to) {
 	for (std::list<boost::shared_ptr<Swift::Message> >::const_iterator it = m_cachedMessages.begin(); it != m_cachedMessages.end(); it++) {
 		if (to.isValid()) {
 			(*it)->setTo(to);
+		}
 		else {
 			(*it)->setTo(m_jid.toBare());
+		}
 		m_conversationManager->getComponent()->getFrontend()->sendMessage(*it);
+	}
 	if (m_subject) {
 		if (to.isValid()) {
 			m_subject->setTo(to);
+		}
 		else {
 			m_subject->setTo(m_jid.toBare());
+		}
 		m_conversationManager->getComponent()->getFrontend()->sendMessage(m_subject);
+	}
 	m_cachedMessages.clear();
+}
 Swift::Presence::ref Conversation::generatePresence(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname, const std::string &iconhash) {
 	std::string nickname = nick;
 	Swift::Presence::ref presence = Swift::Presence::create();
 	std::string legacyName = m_legacyName;
 	if (m_muc) {
 		if (!m_mucEscaping && legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		legacyName = Swift::JID::getEscapedNode(legacyName);
+	}
 	presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 	presence->setType(Swift::Presence::Available);
 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	Swift::StatusShow s((Swift::StatusShow::Type) status);
 	if (s.getType() == Swift::StatusShow::None) {
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	presence->setShow(s.getType());
 	Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 	if (m_nickname == nickname) {
 		if (flag & PARTICIPANT_FLAG_CONFLICT) {
 			delete p;
 			presence->setType(Swift::Presence::Error);
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::Conflict)));
 			return presence;
+		}
 		else if (flag & PARTICIPANT_FLAG_NOT_AUTHORIZED) {
 			delete p;
 			presence->setType(Swift::Presence::Error);
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::NotAuthorized, Swift::ErrorPayload::Auth, statusMessage)));
 			return presence;
+		}
 		else if (flag & PARTICIPANT_FLAG_ROOM_NOT_FOUD) {
 			delete p;
 			presence->setType(Swift::Presence::Error);
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::ErrorPayload(Swift::ErrorPayload::ItemNotFound, Swift::ErrorPayload::Cancel, statusMessage)));
 			return presence;
+		}
 		else {
 			Swift::MUCUserPayload::StatusCode c;
 			c.code = 110;
 			p->addStatusCode(c);
 			if (m_nicknameChanged) {
 				Swift::MUCUserPayload::StatusCode c;
 				c.code = 210;
 				p->addStatusCode(c);
 				m_nicknameChanged = false;
+			}
 			m_sentInitialPresence = true;
+		}
+	}
 	Swift::MUCItem item;
 	item.affiliation = Swift::MUCOccupant::Member;
 	item.role = Swift::MUCOccupant::Participant;
 	if (flag & PARTICIPANT_FLAG_MODERATOR) {
 		item.affiliation = Swift::MUCOccupant::Admin;
 		item.role = Swift::MUCOccupant::Moderator;
+	}
 	if (!newname.empty()) {
 		item.nick = newname;
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 303;
 		p->addStatusCode(c);
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	if (!iconhash.empty()) {
 		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (iconhash)));
+	}
 	p->addItem(item);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
 	return presence;
+}
 void Conversation::setNickname(const std::string &nickname) {
 	if (!nickname.empty() && m_nickname != nickname) {
 		m_nicknameChanged = true;
+	}
 	m_nickname = nickname;
+}
 void Conversation::handleRawPresence(Swift::Presence::ref presence) {
 	// TODO: Detect nickname change.
 	m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
 	m_participants[presence->getFrom().getResource()].presence = presence;
+}
 void Conversation::removeJID(const Swift::JID &jid) {
 	m_jids.remove(jid);
+}
 void Conversation::handleParticipantChanged(const std::string &nick, Conversation::ParticipantFlag flag, int status, const std::string &statusMessage, const std::string &newname, const std::string &iconhash, const std::string &alias) {
 	Swift::Presence::ref presence = generatePresence(alias.empty() ? nick : alias, flag, status, statusMessage, newname, iconhash);
 	if (presence->getType() == Swift::Presence::Unavailable) {
 		m_participants.erase(nick);
+	}
 	else {
 		m_participants[nick].presence = presence;
 		m_participants[nick].alias = alias;
+	}
 	BOOST_FOREACH(const Swift::JID &jid, m_jids) {
 		presence->setTo(jid);
 		m_conversationManager->getComponent()->getFrontend()->sendPresence(presence);
+	}
 	if (!newname.empty()) {
 		handleParticipantChanged(newname, flag, status, statusMessage, "", iconhash);
+	}
 	if (m_sentInitialPresence && !m_sentInitialSubject && m_subject) {
 		m_sentInitialSubject = true;
 		m_conversationManager->getComponent()->getFrontend()->sendMessage(m_subject);
+	}
 	// We send error presences only to inform user that he is disconnected
 	// from the room. This code must be extended in case we start sending error
 	// presences in other situations.
 	if (presence->getType() == Swift::Presence::Error) {
 		m_conversationManager->getUser()->leaveRoom(m_legacyName);
+	}
+}
+}

tests/libtransport/user.cpp

➞

Show inline comments

@@ @@ -4,392 +4,392 @@ @@
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 using namespace Transport;
 #if !HAVE_SWIFTEN_3
 #define get_value_or(X) substr()
 #endif
 class UserTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(UserTest);
 	CPPUNIT_TEST(sendCurrentPresence);
     CPPUNIT_TEST(handlePresence);
 	CPPUNIT_TEST(handlePresenceJoinRoom);
 	CPPUNIT_TEST(handlePresenceJoinRoomTwoResources);
 	CPPUNIT_TEST(handlePresenceLeaveRoom);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResources);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResourcesOneDisconnects);
 	CPPUNIT_TEST(handlePresenceLeaveRoomBouncer);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResourcesBouncer);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResourcesOneDisconnectsBouncer);
 	CPPUNIT_TEST(handlePresenceLeaveRoomTwoResourcesAnotherOneDisconnects);
 	CPPUNIT_TEST(leaveJoinedRoom);
 	CPPUNIT_TEST(joinRoomBeforeConnected);
 	CPPUNIT_TEST(handleDisconnected);
 	CPPUNIT_TEST(handleDisconnectedReconnect);
 	CPPUNIT_TEST(joinRoomHandleDisconnectedRejoin);
 	CPPUNIT_TEST(joinRoomAfterFlagNotAuthorized);
 	CPPUNIT_TEST(requestVCard);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		std::string room;
 		std::string roomNickname;
 		std::string roomPassword;
 		std::string photo;
 		bool readyToConnect;
 		bool disconnected;
 		Swift::Presence::ref changedPresence;
 		void setUp (void) {
 			disconnected = false;
 			readyToConnect = false;
 			changedPresence = Swift::Presence::ref();
 			room = "";
 			roomNickname = "";
 			roomPassword = "";
 			photo = "";
 			setMeUp();
 			userManager->onUserCreated.connect(boost::bind(&UserTest::handleUserCreated, this, _1));
 			connectUser();
 			received.clear();
 			frontend->onVCardUpdated.connect(boost::bind(&UserTest::handleVCardUpdated, this, _1, _2));
+		}
 		void tearDown (void) {
 			received.clear();
 			if (!disconnected) {
 				disconnectUser();
+			}
 			userManager->removeAllUsers();
 			tearMeDown();
+		}
 	void handleVCardUpdated(User *user, boost::shared_ptr<Swift::VCard> v) {
 		photo = Swift::byteArrayToString(v->getPhoto());
+	}
 	void handleUserCreated(User *user) {
 		user->onReadyToConnect.connect(boost::bind(&UserTest::handleUserReadyToConnect, this, user));
 		user->onPresenceChanged.connect(boost::bind(&UserTest::handleUserPresenceChanged, this, user, _1));
 		user->onRoomJoined.connect(boost::bind(&UserTest::handleRoomJoined, this, user, _1, _2, _3, _4));
 		user->onRoomLeft.connect(boost::bind(&UserTest::handleRoomLeft, this, user, _1));
+	}
 	void handleUserReadyToConnect(User *user) {
 		readyToConnect = true;
+	}
 	void handleUserPresenceChanged(User *user, Swift::Presence::ref presence) {
 		changedPresence = presence;
+	}
 	void handleRoomJoined(User *user, const std::string &jid, const std::string &r, const std::string &nickname, const std::string &password) {
 		room = r;
 		roomNickname = nickname;
 		roomPassword = password;
+	}
 	void handleRoomLeft(User *user, const std::string &r) {
 		room = r;
+	}
 	void sendCurrentPresence() {
 		User *user = userManager->getUser("user@localhost");
 		user->sendCurrentPresence();
 		// We're not forwarding current presence in server-mode
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
+	}
 	void handlePresence() {
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		response->setShow(Swift::StatusShow::Away);
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		CPPUNIT_ASSERT(changedPresence);
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, changedPresence->getShow());
+	}
 	void handlePresenceJoinRoom() {
 		User *user = userManager->getUser("user@localhost");
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);
 		room = "";
 		roomNickname = "";
 		roomPassword = "";
 		// simulate that backend joined the room
 		TestingConversation *conv = new TestingConversation(user->getConversationManager(), "room", true);
 		conv->addJID("user@localhost/resource");
 		conv->setNickname("hanzz");
 		user->getConversationManager()->addConversation(conv);
 		received.clear();
 		injectPresence(response);
 		loop->processEvents();
 		// no presence received in server mode, just disco#info
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceJoinRoomTwoResources() {
 		handlePresenceJoinRoom();
 		User *user = userManager->getUser("user@localhost");
 		// Add 1 participant
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, Swift::StatusShow::Away, "my status message");
 		// Connect 2nd resource
 		connectSecondResource();
 		received2.clear();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		CPPUNIT_ASSERT_EQUAL(1, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received2[0])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource2"), dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("room@localhost/anotheruser"), dynamic_cast<Swift::Presence *>(getStanza(received2[0]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received2[0])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Member, *getStanza(received2[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Participant, *getStanza(received2[0])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
 		CPPUNIT_ASSERT_EQUAL(2, (int) received2.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received2[1])));
 		CPPUNIT_ASSERT_EQUAL(Swift::StatusShow::Away, dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getShow());
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource2"), dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("room@localhost/anotheruser"), dynamic_cast<Swift::Presence *>(getStanza(received2[1]))->getFrom().toString());
 		CPPUNIT_ASSERT(getStanza(received2[1])->getPayload<Swift::MUCUserPayload>());
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Member, *getStanza(received2[1])->getPayload<Swift::MUCUserPayload>()->getItems()[0].affiliation);
 		CPPUNIT_ASSERT_EQUAL(Swift::MUCOccupant::Participant, *getStanza(received2[1])->getPayload<Swift::MUCUserPayload>()->getItems()[0].role);
+	}
 	void handlePresenceLeaveRoom() {
 		received.clear();
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 // 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 // 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 // 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResources() {
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		// disconnect also from resource
 		// User is still connected from resource2, so he should not leave the room
 		response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		response->setType(Swift::Presence::Unavailable);
 		payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesOneDisconnects() {
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		User *user = userManager->getUser("user@localhost");
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		CPPUNIT_ASSERT_EQUAL(1, (int) conv->getJIDs().size());
 		CPPUNIT_ASSERT_EQUAL(Swift::JID("user@localhost/resource2"), conv->getJIDs().front());
+	}
 	void handlePresenceLeaveRoomTwoResourcesAnotherOneDisconnects() {
 		handlePresenceJoinRoom();
 		User *user = userManager->getUser("user@localhost");
 		// Add 1 participant
 		Conversation *conv = user->getConversationManager()->getConversation("room");
 		conv->handleParticipantChanged("anotheruser", Conversation::PARTICIPANT_FLAG_NONE, Swift::StatusShow::Away, "my status message");
 		// Connect 2nd resource
 		connectSecondResource();
 		received2.clear();
 		received.clear();
 		// User is still connected from resource2, but not in room, so we should leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		conv = user->getConversationManager()->getConversation("room");
 		CPPUNIT_ASSERT(!conv);
+	}
 	void handlePresenceLeaveRoomBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesBouncer() {
 		User *user = userManager->getUser("user@localhost");
 		user->addUserSetting("stay_connected", "1");
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Unavailable);
 		Swift::MUCPayload *payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string(""), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		room = "something";
 		// disconnect also from resource
 		// User is still connected from resource2, so he should not leave the room
 		response = Swift::Presence::create();
 		response->setTo("room@localhost/hanzz");
 		response->setFrom("user@localhost/resource2");
 		response->setType(Swift::Presence::Unavailable);
 		payload = new Swift::MUCPayload();
 		payload->setPassword("password");
 		response->addPayload(boost::shared_ptr<Swift::Payload>(payload));
 		injectPresence(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
 		CPPUNIT_ASSERT_EQUAL(std::string("something"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
+	}
 	void handlePresenceLeaveRoomTwoResourcesOneDisconnectsBouncer() {
 		room = "something";
 		handlePresenceJoinRoomTwoResources();
 		received.clear();
 		User *user = userManager->getUser("user@localhost");
 		// User is still connected from resource2, so he should not leave the room
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost/hanzz");

0 comments (0 inline, 0 general)