libtransport.git Changeset - 7ba8909d719f

Changeset - 7ba8909d719f

Parent rev.

Child rev.

[Not reviewed]

0 9 0

Jan Kaluza - 10 years ago 2016-02-15 12:21:04
jkaluza@redhat.com

Use value_or instead of get_value_or

9 files changed with 16 insertions and 16 deletions:

libtransport/AdminInterface.cpp

libtransport/NetworkPluginServer.cpp

libtransport/UserManager.cpp

spectrum/src/frontends/slack/SlackSession.cpp

spectrum/src/frontends/slack/SlackUserManager.cpp

tests/libtransport/conversationmanager.cpp

tests/libtransport/user.cpp

tests/libtransport/usermanager.cpp

tests/libtransport/userregistration.cpp

0 comments (0 inline, 0 general)

libtransport/AdminInterface.cpp

➞

Show inline comments

@@ @@ -19,97 +19,97 @@ @@
  */
 #include "transport/AdminInterface.h"
 #include "transport/User.h"
 #include "transport/Transport.h"
 #include "transport/StorageBackend.h"
 #include "transport/UserManager.h"
 #include "transport/NetworkPluginServer.h"
 #include "transport/Logging.h"
 #include "transport/UserRegistration.h"
 #include "transport/Frontend.h"
 #include "transport/MemoryUsage.h"
 #include "transport/Config.h"
 #include <boost/foreach.hpp>
 #include <boost/lexical_cast.hpp>
 #include <Swiften/Version.h>
 #define HAVE_SWIFTEN_3  (SWIFTEN_VERSION >= 0x030000)
 namespace Transport {
 DEFINE_LOGGER(logger, "AdminInterface");
 static std::string getArg(const std::string &body) {
 	std::string ret;
 	if (body.find(" ") == std::string::npos)
 		return ret;
 	return body.substr(body.find(" ") + 1);
+}
 AdminInterface::AdminInterface(Component *component, UserManager *userManager, NetworkPluginServer *server, StorageBackend *storageBackend, UserRegistration *userRegistration) {
 	m_component = component;
 	m_storageBackend = storageBackend;
 	m_userManager = userManager;
 	m_server = server;
 	m_userRegistration = userRegistration;
 	m_start = time(NULL);
 	m_component->getFrontend()->onMessageReceived.connect(bind(&AdminInterface::handleMessageReceived, this, _1));
+}
 AdminInterface::~AdminInterface() {
+}
 void AdminInterface::handleQuery(Swift::Message::ref message) {
 #if HAVE_SWIFTEN_3
-	std::string msg = message->getBody().value_or("");
+	std::string msg = message->getBody().get_value_or("");
 #else
 	std::string msg = message->getBody();
 #endif
 	LOG4CXX_INFO(logger, "Message from admin received: '" << msg << "'");
 	message->setTo(message->getFrom());
 	message->setFrom(m_component->getJID());
 	if (msg == "status") {
 		int users = m_userManager->getUserCount();
 		int backends = m_server->getBackendCount();
 		message->setBody("Running (" + boost::lexical_cast<std::string>(users) + " users connected using " + boost::lexical_cast<std::string>(backends) + " backends)");
+	}
 	else if (msg == "uptime") {
 		message->setBody(boost::lexical_cast<std::string>(time(0) - m_start));
+	}
 	else if (msg == "online_users") {
 		std::string lst;
 		const std::map<std::string, User *> &users = m_userManager->getUsers();
 		if (users.size() == 0)
 			lst = "0";
 		for (std::map<std::string, User *>::const_iterator it = users.begin(); it != users.end(); it ++) {
 			lst += (*it).first + "\n";
+		}
 		message->setBody(lst);
+	}
 	else if (msg == "online_users_count") {
 		int users = m_userManager->getUserCount();
 		message->setBody(boost::lexical_cast<std::string>(users));
+	}
 	else if (msg == "reload") {
 		bool done = m_component->getConfig()->reload();
 		if (done) {
 			message->setBody("Config reloaded");
+		}
 		else {
 			message->setBody("Error during config reload");
+		}
+	}
 	else if (msg == "online_users_per_backend") {
 		std::string lst;
 		int id = 1;
 		const std::list <NetworkPluginServer::Backend *> &backends = m_server->getBackends();
 		for (std::list <NetworkPluginServer::Backend *>::const_iterator b = backends.begin(); b != backends.end(); b++) {
 			NetworkPluginServer::Backend *backend = *b;
 			lst += "Backend " + boost::lexical_cast<std::string>(id) + " (ID=" + backend->id + ")";
 		help += "    online_users - returns list of all online users\n";
 		help += "    online_users_count - number of online users\n";
 		help += "    online_users_per_backend - shows online users per backends\n";
 		help += "    has_online_user <bare_JID> - returns 1 if user is online\n";
 		if (m_userRegistration) {
 			help += "    register <bare_JID> <legacyName> <password> - registers the new user\n";
 			help += "    unregister <bare_JID> - unregisters existing user\n";
+		}
 		help += "Messages:\n";
 		help += "    messages_from_xmpp - get number of messages received from XMPP users\n";
 		help += "    messages_to_xmpp - get number of messages sent to XMPP users\n";
 		help += "Frontend:\n";
 		help += "    set_oauth2_code <code> <state> - sets the OAuth2 code and state for this instance\n";
 		help += "Backends:\n";
 		help += "    backends_count - number of active backends\n";
 		help += "    crashed_backends - returns IDs of crashed backends\n";
 		help += "    crashed_backends_count - returns number of crashed backends\n";
 		help += "Memory:\n";
 		help += "    res_memory - Total RESident memory spectrum2 and its backends use in KB\n";
 		help += "    shr_memory - Total SHaRed memory spectrum2 backends share together in KB\n";
 		help += "    used_memory - (res_memory - shr_memory)\n";
 		help += "    average_memory_per_user - (memory_used_without_any_user - res_memory)\n";
 		help += "    res_memory_per_backend - RESident memory used by backends in KB\n";
 		help += "    shr_memory_per_backend - SHaRed memory used by backends in KB\n";
 		help += "    used_memory_per_backend - (res_memory - shr_memory) per backend\n";
 		help += "    average_memory_per_user_per_backend - (memory_used_without_any_user - res_memory) per backend\n";
 		message->setBody(help);
+	}
 	else {
 		message->setBody("Unknown command \"" + msg + "\". Try \"help\"");
+	}
+}
 void AdminInterface::handleMessageReceived(Swift::Message::ref message) {
 	if (!message->getTo().getNode().empty())
 		return;
 	std::vector<std::string> const &x = CONFIG_VECTOR(m_component->getConfig(),"service.admin_jid");
 	if (std::find(x.begin(), x.end(), message->getFrom().toBare().toString()) == x.end()) {
 	    LOG4CXX_WARN(logger, "Message not from admin user, but from " << message->getFrom().toBare().toString());
 	    return;
+	}
 	// Ignore empty messages
 #if HAVE_SWIFTEN_3
-	if (message->getBody().value_or("").empty()) {
+	if (message->getBody().get_value_or("").empty()) {
 		return;
+	}
 #else
 	if (message->getBody().empty()) {
 		return;
+	}
 #endif
 	handleQuery(message);
 	m_component->getFrontend()->sendMessage(message);
+}
+}

libtransport/NetworkPluginServer.cpp

➞

Show inline comments

@@ @@ -926,97 +926,97 @@ void NetworkPluginServer::connectWaitingUsers() { @@
 		LOG4CXX_INFO(logger, "Associating " << u->getJID().toString() << " with this backend");
 		// associate backend with user
 		handleUserCreated(u);
 		// connect user if it's ready
 		if (u->isReadyToConnect()) {
 			handleUserReadyToConnect(u);
+		}
+	}
+}
 void NetworkPluginServer::handlePongReceived(Backend *c) {
 	// This could be first PONG from the backend
 	if (c->pongReceived == -1) {
 		// Backend is fully ready to handle requests
 		c->willDie = false;
 		if (m_firstPong) {
 			// first backend connected, start the server, we're ready.
 			m_component->start();
 			m_firstPong = false;
+		}
 		connectWaitingUsers();
+	}
 	c->pongReceived = true;
+}
 void NetworkPluginServer::handleQueryPayload(Backend *b, const std::string &data) {
 	pbnetwork::BackendConfig payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	if (!m_adminInterface) {
 		return;
+	}
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(payload.config());
 	m_adminInterface->handleQuery(msg);
 	pbnetwork::BackendConfig response;
 #if HAVE_SWIFTEN_3
-	response.set_config(msg->getBody().value_or(""));
+	response.set_config(msg->getBody().get_value_or(""));
 #else
 	response.set_config(msg->getBody());
 #endif
 	std::string message;
 	response.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_QUERY);
 	send(b->connection, message);
+}
 void NetworkPluginServer::handleBackendConfigPayload(const std::string &data) {
 	pbnetwork::BackendConfig payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	m_config->updateBackendConfig(payload.config());
+}
 void NetworkPluginServer::handleRoomListPayload(const std::string &data) {
 	pbnetwork::RoomList payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	if (!payload.user().empty()) {
 		User *user = m_userManager->getUser(payload.user());
 		if (!user) {
 			LOG4CXX_ERROR(logger, "Room list payload received for unknown user " << payload.user());
 			return;
+		}
 		user->clearRoomList();
 		for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {
 			user->addRoomToRoomList(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));
+		}
+	}
 	else {
 		m_component->getFrontend()->clearRoomList();
 		for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {
 			m_component->getFrontend()->addRoomToRoomList(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));
+		}
+	}
+}
 			msg->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));
+		}
 		std::string xml = safeByteArrayToString(m_serializer->serializeElement(msg));
 		WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);
 		send(c->connection, xml);
 		return;
+	}
 	boost::shared_ptr<Swift::ChatState> statePayload = msg->getPayload<Swift::ChatState>();
 	if (statePayload) {
 		pbnetwork::WrapperMessage_Type type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED;
 		switch (statePayload->getChatState()) {
 			case Swift::ChatState::Active:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING;
 				break;
 			case Swift::ChatState::Composing:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING;
 				break;
 			case Swift::ChatState::Paused:
 				type = pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED;
 				break;
 			default:
 				break;
+		}
 		if (type != pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED) {
 			pbnetwork::Buddy buddy;
 			buddy.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 			buddy.set_buddyname(conv->getLegacyName());
 			std::string message;
 			buddy.SerializeToString(&message);
 			WRAP(message, type);
 			Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 			if (!c) {
 				return;
+			}
 			send(c->connection, message);
+		}
+	}
 	boost::shared_ptr<Swift::AttentionPayload> attentionPayload = msg->getPayload<Swift::AttentionPayload>();
 	if (attentionPayload) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 #if HAVE_SWIFTEN_3
-		m.set_message(msg->getBody().value_or(""));
+		m.set_message(msg->getBody().get_value_or(""));
 #else
 		m.set_message(msg->getBody());
 #endif
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ATTENTION);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	if (!msg->getSubject().empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(msg->getSubject());
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		send(c->connection, message);
 		return;
+	}
 	std::string xhtml;
 	boost::shared_ptr<Swift::XHTMLIMPayload> xhtmlPayload = msg->getPayload<Swift::XHTMLIMPayload>();
 	if (xhtmlPayload) {
 		xhtml = xhtmlPayload->getBody();
+	}
 	// Send normal message
 #if HAVE_SWIFTEN_3
-	std::string body = msg->getBody().value_or("");
+	std::string body = msg->getBody().get_value_or("");
 #else
 	std::string body = msg->getBody();
 #endif
 	if (!body.empty() || !xhtml.empty()) {
 		pbnetwork::ConversationMessage m;
 		m.set_username(conv->getConversationManager()->getUser()->getJID().toBare());
 		m.set_buddyname(conv->getLegacyName());
 		m.set_message(body);
 		m.set_xhtml(xhtml);
 		boost::shared_ptr<Swift::DeliveryReceiptRequest> receiptPayload = msg->getPayload<Swift::DeliveryReceiptRequest>();
 		if (receiptPayload && !msg->getID().empty()) {
 			m.set_id(msg->getID());
+		}
 		std::string message;
 		m.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE);
 		Backend *c = (Backend *) conv->getConversationManager()->getUser()->getData();
 		if (!c) {
 			return;
+		}
 		send(c->connection, message);
+	}
+}
 void NetworkPluginServer::handleBuddyRemoved(Buddy *b) {
 	User *user = b->getRosterManager()->getUser();
 	pbnetwork::Buddy buddy;
 	buddy.set_username(user->getJID().toBare());
 	buddy.set_buddyname(b->getName());
 	buddy.set_alias(b->getAlias());
 	BOOST_FOREACH(const std::string &g, b->getGroups()) {
 		buddy.add_group(g);
+	}
 	buddy.set_status(pbnetwork::STATUS_NONE);
 	std::string message;
 	buddy.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED);
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}

libtransport/UserManager.cpp

➞

Show inline comments

 		if (user) {
 			if (user->getUserSetting("stay_connected") == "1") {
 				return;
+			}
 			Swift::Presence::ref highest = m_component->getPresenceOracle()->getHighestPriorityPresence(presence->getFrom().toBare());
 			// There's no presence for this user, so disconnect
 			if (!highest || (highest && highest->getType() == Swift::Presence::Unavailable)) {
 				m_removeTimer->onTick.connect(boost::bind(&UserManager::handleRemoveTimeout, this, user->getJID().toBare().toString(), user, false));
 				m_removeTimer->start();
+			}
+		}
+	}
+}
 void UserManager::handleRemoveTimeout(const std::string jid, User *u, bool reconnect) {
 	m_removeTimer->onTick.disconnect(boost::bind(&UserManager::handleRemoveTimeout, this, jid, u, reconnect));
 	// Maybe this User instance has been deleted in mean time and we would remove new one,
 	// so better check for it and ignore deletion if "u" does not exist anymore.
 	User *user = getUser(jid);
 	if (user != u) {
 		return;
+	}
 	// Remove user
 	if (user) {
 		removeUser(user);
+	}
 	// Connect the user again when we're reconnecting.
 	if (reconnect) {
 		connectUser(jid);
+	}
+}
 void UserManager::handleMessageReceived(Swift::Message::ref message) {
 	if (message->getType() == Swift::Message::Error) {
 		return;
+	}
 	// Do not count chatstate notification...
 	boost::shared_ptr<Swift::ChatState> statePayload = message->getPayload<Swift::ChatState>();
 	if (!statePayload) {
 		messageToBackendSent();
+	}
 #if HAVE_SWIFTEN_3
-	std::string body = message->getBody().value_or("");
+	std::string body = message->getBody().get_value_or("");
 #else
 	std::string body = message->getBody();
 #endif
 	if (body.empty() && !statePayload && message->getSubject().empty()) {
 		return;
+	}
 	User *user = getUser(message->getFrom().toBare().toString());
 	if (!user){
 		return;
+	}
 	user->getConversationManager()->handleMessageReceived(message);
+}
 void UserManager::handleGeneralPresenceReceived(Swift::Presence::ref presence) {
 	LOG4CXX_INFO(logger, "PRESENCE2 " << presence->getTo().toString());
 	switch(presence->getType()) {
 		case Swift::Presence::Subscribe:
 		case Swift::Presence::Subscribed:
 		case Swift::Presence::Unsubscribe:
 		case Swift::Presence::Unsubscribed:
 			handleSubscription(presence);
 			break;
 		case Swift::Presence::Available:
 		case Swift::Presence::Unavailable:
 			handleMUCPresence(presence);
 			break;
 		case Swift::Presence::Probe:
 			handleProbePresence(presence);
 			break;
 		case Swift::Presence::Error:
 			handleErrorPresence(presence);
 			break;
 		default:
 			break;
 	};
+}
 void UserManager::handleMUCPresence(Swift::Presence::ref presence) {
 	// Don't let RosterManager to handle presences for us
 	if (presence->getTo().getNode().empty()) {
 		return;
+	}
 	if (presence->getType() == Swift::Presence::Available) {
 		handlePresence(presence);
+	}

spectrum/src/frontends/slack/SlackSession.cpp

➞

Show inline comments

@@ @@ -106,97 +106,97 @@ void SlackSession::sendOnlineBuddies() { @@
+		}
+	}
 	m_onlineBuddiesTimer->start();
+}
 void SlackSession::sendMessageToAll(const std::string &msg) {
 	std::vector<std::string> channels;
 	for (std::map<std::string, std::string>::const_iterator it = m_jid2channel.begin(); it != m_jid2channel.end(); it++) {
 		if (std::find(channels.begin(), channels.end(), it->second) == channels.end()) {
 			channels.push_back(it->second);
 			m_rtm->getAPI()->sendMessage("Spectrum 2", it->second, msg);
+		}
+	}
+}
 void SlackSession::sendMessage(boost::shared_ptr<Swift::Message> message) {
 	if (m_user) {
 		std::map<std::string, Conversation *> convs = m_user->getConversationManager()->getConversations();
 		for (std::map<std::string, Conversation *> ::const_iterator it = convs.begin(); it != convs.end(); it++) {
 			Conversation *conv = it->second;
 			if (!conv) {
 				continue;
+			}
 			if (conv->getNickname() == message->getFrom().getResource()) {
 				return;
+			}
+		}
+	}
 	std::string from = message->getFrom().getResource();
 	std::string channel = m_jid2channel[message->getFrom().toBare().toString()];
 	if (channel.empty()) {
 		if (m_slackChannel.empty()) {
 			LOG4CXX_ERROR(logger, m_uinfo.jid << ": Received message for unknown channel from " << message->getFrom().toBare().toString());
 			return;
+		}
 		channel = m_slackChannel;
 		from = Buddy::JIDToLegacyName(message->getFrom(), m_user);
 		Buddy *b;
 		if (m_user && (b = m_user->getRosterManager()->getBuddy(from)) != NULL) {
 			from = b->getAlias() + " (" + from + ")";
+		}
+	}
 	LOG4CXX_INFO(logger, m_uinfo.jid << "Sending message to Slack channel " << channel << " from " << from);
 #if HAVE_SWIFTEN_3
-	std::string body = message->getBody().value_or("");
+	std::string body = message->getBody().get_value_or("");
 #else
 	std::string body = message->getBody();
 #endif
 	m_rtm->getAPI()->sendMessage(from, channel, body);
+}
 void SlackSession::setPurpose(const std::string &purpose, const std::string &channel) {
 	std::string ch = channel;
 	if (ch.empty()) {
 		ch = m_slackChannel;
+	}
 	if (ch.empty()) {
 		return;
+	}
 	LOG4CXX_INFO(logger, m_uinfo.jid << ": Setting channel purppose: " << ch << " " << purpose);
 	m_api->setPurpose(ch, purpose);
+}
 void SlackSession::handleJoinRoomCreated(const std::string &channelId, std::vector<std::string> args) {
 	args[5] = channelId;
 	std::string &name = args[2];
 	std::string &legacyRoom = args[3];
 	std::string &legacyServer = args[4];
 	std::string &slackChannel = args[5];
 	std::string to = legacyRoom + "%" + legacyServer + "@" + m_component->getJID().toString();
 // 	if (!CONFIG_BOOL_DEFAULTED(m_component->getConfig(), "registration.needRegistration", true)) {
 // 		m_uinfo.uin = name;
 // 		m_storageBackend->setUser(m_uinfo);
 // 	}
 	LOG4CXX_INFO(logger, m_uinfo.jid << ": Channel " << args[5] << " is created. Joining the room on legacy network.");
 	m_jid2channel[to] = slackChannel;
 	m_channel2jid[slackChannel] = to;
 	Swift::Presence::ref presence = Swift::Presence::create();
 	presence->setFrom(Swift::JID(m_uinfo.jid + "/default"));
 	presence->setTo(Swift::JID(to + "/" + name));
 	presence->setType(Swift::Presence::Available);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::MUCPayload()));
 	m_component->getFrontend()->onPresenceReceived(presence);
 	m_onlineBuddiesTimer->start();
+}
 void SlackSession::handleJoinMessage(const std::string &message, std::vector<std::string> &args, bool quiet) {

spectrum/src/frontends/slack/SlackUserManager.cpp

➞

Show inline comments

 void SlackUserManager::sendVCard(unsigned int id, Swift::VCard::ref vcard) {
+}
 void SlackUserManager::sendMessage(boost::shared_ptr<Swift::Message> message) {
 	User *user = getUser(message->getTo().toBare().toString());
 	if (!user) {
 		LOG4CXX_ERROR(logger, "Received message for unknown user " << message->getTo().toBare().toString());
 		return;
+	}
 	static_cast<SlackUser *>(user)->getSession()->sendMessage(message);
+}
 SlackSession *SlackUserManager::moveTempSession(const std::string &user) {
 	if (m_tempSessions.find(user) != m_tempSessions.end()) {
 		SlackSession *session = m_tempSessions[user];
 		m_tempSessions.erase(user);
 		return session;
+	}
 	return NULL;
+}
 void SlackUserManager::moveTempSession(const std::string &user, SlackSession *session) {
 	m_tempSessions[user] = session;
 	session->setUser(NULL);
+}
 UserRegistration *SlackUserManager::getUserRegistration() {
 	return m_userRegistration;
+}
 std::string SlackUserManager::handleOAuth2Code(const std::string &code, const std::string &state) {
 	return static_cast<SlackUserRegistration *>(m_userRegistration)->handleOAuth2Code(code, state);
+}
 std::string SlackUserManager::getOAuth2URL(const std::vector<std::string> &args) {
 	return static_cast<SlackUserRegistration *>(m_userRegistration)->createOAuth2URL(args);
+}
 void SlackUserManager::handleUserCreated(User *user) {
 	LOG4CXX_INFO(logger, "handleUserCreated");
 	static_cast<SlackUser *>(user)->getSession()->handleConnected();
+}
 bool SlackUserManager::handleAdminMessage(Swift::Message::ref message) {
 #if HAVE_SWIFTEN_3
-	std::string body = message->getBody().value_or("");
+	std::string body = message->getBody().get_value_or("");
 #else
 	std::string body = message->getBody();
 #endif
 	if (body.find("list_rooms") == 0) {
 		std::vector<std::string> args;
 		boost::split(args, body, boost::is_any_of(" "));
 		if (args.size() == 2) {
 			UserInfo uinfo;
 			if (!m_storageBackend->getUser(args[1], uinfo)) {
 				message->setBody("Error: Unknown user");
 				return true;
+			}
 			std::string rooms = "";
 			int type = (int) TYPE_STRING;
 			m_storageBackend->getUserSetting(uinfo.id, "rooms", type, rooms);
 			message->setBody(rooms);
 			return true;
+		}
+	}
 	else if (body.find("join_room ") == 0) {
 		std::vector<std::string> args;
 		boost::split(args, body, boost::is_any_of(" "));
 		if (args.size() == 6) {
 			UserInfo uinfo;
 			if (!m_storageBackend->getUser(args[1], uinfo)) {
 				message->setBody("Error: Unknown user");
 				return true;
+			}
 			std::string rooms = "";
 			int type = (int) TYPE_STRING;
 			m_storageBackend->getUserSetting(uinfo.id, "rooms", type, rooms);
 			rooms += body + "\n";
 			m_storageBackend->updateUserSetting(uinfo.id, "rooms", rooms);
 			SlackUser *user = static_cast<SlackUser *>(getUser(args[1]));
 			if (user) {
 				user->getSession()->handleJoinMessage("", args, true);
+			}
 			message->setBody("Joined the room");
 			return true;
+		}
+	}
 	else if (body.find("leave_room ") == 0) {
 		std::vector<std::string> args;

tests/libtransport/conversationmanager.cpp

➞

Show inline comments

 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include <Swiften/Elements/VCardUpdate.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 value_or(X) substr()
+#define get_value_or(X) substr()
 #endif
 class ConversationManagerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(ConversationManagerTest);
 	CPPUNIT_TEST(conversationSize);
 	CPPUNIT_TEST(handleNormalMessages);
 	CPPUNIT_TEST(handleNormalMessagesInitiatedFromXMPP);
 	CPPUNIT_TEST(handleNormalMessagesHeadline);
 	CPPUNIT_TEST(handleGroupchatMessages);
 	CPPUNIT_TEST(handleGroupchatMessagesAlias);
 	CPPUNIT_TEST(handleGroupchatMessagesBouncer);
 	CPPUNIT_TEST(handleGroupchatMessagesBouncerLeave);
 	CPPUNIT_TEST(handleGroupchatMessagesTwoResources);
 	CPPUNIT_TEST(handleChatstateMessages);
 	CPPUNIT_TEST(handleSubjectMessages);
 	CPPUNIT_TEST(handleParticipantChanged);
 	CPPUNIT_TEST(handleParticipantChangedEscaped);
 	CPPUNIT_TEST(handleParticipantChangedEscaped2);
 	CPPUNIT_TEST(handleParticipantChangedTwoResources);
 	CPPUNIT_TEST(handleParticipantChangedIconHash);
 	CPPUNIT_TEST(handlePMFromXMPP);
 	CPPUNIT_TEST(handleGroupchatRemoved);
 	CPPUNIT_TEST(handleNicknameConflict);
 	CPPUNIT_TEST(handleNotAuthorized);
 	CPPUNIT_TEST(handleSetNickname);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		TestingConversation *m_conv;
 		boost::shared_ptr<Swift::Message> m_msg;
 		void setUp (void) {
 			m_conv = NULL;
 			m_msg.reset();
 			setMeUp();
 			connectUser();
 			add2Buddies();
 			factory->onMessageToSend.connect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			factory->onMessageToSend.disconnect(boost::bind(&ConversationManagerTest::handleMessageReceived, this, _1, _2));
 			tearMeDown();
+		}

tests/libtransport/user.cpp

➞

Show inline comments

 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #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 value_or(X) substr()
+#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 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");
 		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 leaveJoinedRoom() {
 		User *user = userManager->getUser("user@localhost");
 		handlePresenceJoinRoom();
 		CPPUNIT_ASSERT(user->getConversationManager()->getConversation("room"));
 		received.clear();
 		handlePresenceLeaveRoom();
 		CPPUNIT_ASSERT(!user->getConversationManager()->getConversation("room"));
+	}
 	void handleDisconnected() {
 		User *user = userManager->getUser("user@localhost");
 		user->handleDisconnected("Connection error", Swift::SpectrumErrorPayload::CONNECTION_ERROR_AUTHENTICATION_FAILED);
 		loop->processEvents();
 		CPPUNIT_ASSERT(streamEnded);
 		user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(!user);
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		Swift::Message *m = dynamic_cast<Swift::Message *>(getStanza(received[0]));
-		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), m->getBody().value_or(""));
+		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), m->getBody().get_value_or(""));
 		CPPUNIT_ASSERT(dynamic_cast<Swift::StreamError *>(received[1].get()));
 		CPPUNIT_ASSERT_EQUAL(std::string("Connection error"), dynamic_cast<Swift::StreamError *>(received[1].get())->getText());
 		disconnected = true;
+	}
 	void handleDisconnectedReconnect() {
 		readyToConnect = false;
 		User *user = userManager->getUser("user@localhost");
 		user->handleDisconnected("Connection error");
 		loop->processEvents();
 		CPPUNIT_ASSERT(!streamEnded);
 		user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(user);
 		CPPUNIT_ASSERT(readyToConnect);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		injectPresence(response);
 		loop->processEvents();
+	}
 	void joinRoomBeforeConnected() {
 		User *user = userManager->getUser("user@localhost");
 		user->setConnected(false);
 		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);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string(""), roomPassword);
 		user->setConnected(true);
 		CPPUNIT_ASSERT_EQUAL(std::string("room"), room);
 		CPPUNIT_ASSERT_EQUAL(std::string("hanzz"), roomNickname);
 		CPPUNIT_ASSERT_EQUAL(std::string("password"), roomPassword);

tests/libtransport/usermanager.cpp

➞

Show inline comments

 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #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 value_or(X) substr()
+#define get_value_or(X) substr()
 #endif
 class UserManagerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(UserManagerTest);
 	CPPUNIT_TEST(connectUser);
 	CPPUNIT_TEST(connectTwoResources);
 	CPPUNIT_TEST(connectUserTransportDisabled);
 	CPPUNIT_TEST(connectUserRegistrationNeeded);
 	CPPUNIT_TEST(connectUserRegistrationNeededRegistered);
 	CPPUNIT_TEST(connectUserVipOnlyNonVip);
 	CPPUNIT_TEST(handleProbePresence);
 	CPPUNIT_TEST(disconnectUser);
 	CPPUNIT_TEST(disconnectUserBouncer);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		Swift::Presence::ref changedPresence;
 		void setUp (void) {
 			setMeUp();
+		}
 		void tearDown (void) {
 			tearMeDown();
+		}
 	void connectUserTransportDisabled() {
 		addUser();
 		storage->updateUserSetting(1, "enable_transport", "0");
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		User *user = userManager->getUser("user@localhost");
 		CPPUNIT_ASSERT(!user);
+	}
 	void connectUserRegistrationNeeded() {
 		cfg->updateBackendConfig("[registration]\nneedRegistration=1\n");
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		CPPUNIT_ASSERT(streamEnded);
+	}
 	void connectUserRegistrationNeededRegistered() {
 		addUser();
 		cfg->updateBackendConfig("[registration]\nneedRegistration=1\n");
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(1, userManager->getUserCount());
 		CPPUNIT_ASSERT(!streamEnded);
+	}
 	void connectUserVipOnlyNonVip() {
 		addUser();
 		std::istringstream ifs("service.server_mode = 1\nservice.jid_escaping=0\nservice.jid=localhost\nservice.vip_only=1\nservice.vip_message=Ahoj\n");
 		cfg->load(ifs);
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		userRegistry->isValidUserPassword(Swift::JID("user@localhost/resource"), serverFromClientSession.get(), Swift::createSafeByteArray("password"));
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(3, (int) received.size());
 		CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
-		CPPUNIT_ASSERT_EQUAL(std::string("Ahoj"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody().value_or(""));
+		CPPUNIT_ASSERT_EQUAL(std::string("Ahoj"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody().get_value_or(""));
 		CPPUNIT_ASSERT_EQUAL(std::string("user@localhost/resource"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getTo().toString());
 		CPPUNIT_ASSERT_EQUAL(std::string("localhost"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getFrom().toString());
 		CPPUNIT_ASSERT_EQUAL(0, userManager->getUserCount());
 		CPPUNIT_ASSERT(streamEnded);
 		std::istringstream ifs2("service.server_mode = 1\nservice.jid_escaping=1\nservice.jid=localhost\nservice.more_resources=1\n");
 		cfg->load(ifs2);
+	}
 	void handleProbePresence() {
 		UserInfo info;
 		info.id = 1;
 		info.jid = "user@localhost";
 		storage->setUser(info);
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost/resource");
 		response->setType(Swift::Presence::Probe);
 		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(3, (int) received.size());
 		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoInfo>());
 		Swift::Presence *presence = dynamic_cast<Swift::Presence *>(getStanza(received[1]));
 		CPPUNIT_ASSERT(presence);
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unavailable, presence->getType());
 		presence = dynamic_cast<Swift::Presence *>(getStanza(received[2]));
 		CPPUNIT_ASSERT(presence);
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Probe, presence->getType());
 		received.clear();
 		response = Swift::Presence::create();
 		response->setTo("localhost");
 		response->setFrom("user@localhost");
 		response->setType(Swift::Presence::Unsubscribed);
 		dynamic_cast<Swift::ServerStanzaChannel *>(static_cast<XMPPFrontend *>(component->getFrontend())->getStanzaChannel())->onPresenceReceived(response);
 		loop->processEvents();
 		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 		presence = dynamic_cast<Swift::Presence *>(getStanza(received[1]));
 		CPPUNIT_ASSERT(presence);
 		CPPUNIT_ASSERT_EQUAL(Swift::Presence::Subscribe, presence->getType());
 		received.clear();
 		response = Swift::Presence::create();

tests/libtransport/userregistration.cpp

➞

Show inline comments

 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #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 value_or(X) substr()
+#define get_value_or(X) substr()
 #endif
 class UserRegistrationTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(UserRegistrationTest);
 	CPPUNIT_TEST(getForm);
 	CPPUNIT_TEST(getFormRegistered);
 	CPPUNIT_TEST(registerUser);
 	CPPUNIT_TEST(registerUserWithoutRR);
 	CPPUNIT_TEST(unregisterUser);
 	CPPUNIT_TEST(unregisterEmptyPayload);
 	CPPUNIT_TEST(registerUserNotify);
 	CPPUNIT_TEST(unregisterUserNotify);
 	CPPUNIT_TEST(changePassword);
 	CPPUNIT_TEST(registerUserEmpty);
 	CPPUNIT_TEST(registerUserNoNeedPassword);
 	CPPUNIT_TEST(registerUserFormUnknownType);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		void setUp (void) {
 			setMeUp();
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			tearMeDown();
+		}
 		void getForm() {
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Get, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(new Swift::InBandRegistrationPayload()));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>());
 			CPPUNIT_ASSERT_EQUAL(false, getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->isRegistered());
 			CPPUNIT_ASSERT_EQUAL(std::string(""), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getUsername());
 			CPPUNIT_ASSERT_EQUAL(std::string(""), *getStanza(received[0])->getPayload<Swift::InBandRegistrationPayload>()->getPassword());
+		}
 		void getFormRegistered() {
 			UserInfo user;
 			user.id = -1;
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
 			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Set, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(false, storage->getUser("user@localhost", user));
+		}
 		void registerUserNotify() {
 			std::istringstream ifs("service.server_mode = 1\nregistration.notify_jid=user@localhost\nservice.jid=localhost\nservice.more_resources=1\n");
 			cfg->load(ifs);
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("legacyname");
 			reg->setPassword("password");
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
 			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Set, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT_EQUAL(std::string("localhost"), getStanza(received[0])->getPayload<Swift::RosterPayload>()->getItems()[0].getJID().toString());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
-			CPPUNIT_ASSERT_EQUAL(std::string("registered: user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody().value_or(""));
+			CPPUNIT_ASSERT_EQUAL(std::string("registered: user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody().get_value_or(""));
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(true, storage->getUser("user@localhost", user));
 			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), user.uin);
 			CPPUNIT_ASSERT_EQUAL(std::string("password"), user.password);
+		}
 		void unregisterUserNotify() {
 			registerUserNotify();
 			received.clear();
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setRemove(true);
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[1]))->getType());
 			iq = Swift::IQ::createResult(Swift::JID("localhost"), getStanza(received[0])->getTo(), getStanza(received[0])->getID(), boost::shared_ptr<Swift::Payload>(new Swift::RosterPayload()));
 			received.clear();
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Set, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::RosterPayload>());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[1])));
-			CPPUNIT_ASSERT_EQUAL(std::string("unregistered: user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody().value_or(""));
+			CPPUNIT_ASSERT_EQUAL(std::string("unregistered: user@localhost"), dynamic_cast<Swift::Message *>(getStanza(received[1]))->getBody().get_value_or(""));
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(false, storage->getUser("user@localhost", user));
+		}
 		void changePassword() {
 			registerUser();
 			received.clear();
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("legacyname");
 			reg->setPassword("another");
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Result, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(true, storage->getUser("user@localhost", user));
 			CPPUNIT_ASSERT_EQUAL(std::string("legacyname"), user.uin);
 			CPPUNIT_ASSERT_EQUAL(std::string("another"), user.password);
+		}
 		void registerUserEmpty() {
 			Swift::InBandRegistrationPayload *reg = new Swift::InBandRegistrationPayload();
 			reg->setUsername("");
 			reg->setPassword("password");
 			boost::shared_ptr<Swift::IQ> iq = Swift::IQ::createRequest(Swift::IQ::Set, Swift::JID("localhost"), "id", boost::shared_ptr<Swift::Payload>(reg));
 			iq->setFrom("user@localhost");
 			injectIQ(iq);
 			loop->processEvents();
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Error, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			UserInfo user;
 			CPPUNIT_ASSERT_EQUAL(false, storage->getUser("user@localhost", user));
+		}

0 comments (0 inline, 0 general)