1
0
Fork 0
mirror of https://github.com/vanitasvitae/Smack.git synced 2024-12-24 03:27:59 +01:00
Smack/integration-test/org/jivesoftware/smackx/muc/MultiUserChatTest.java
Florian Schmaus 1e57f1c659 Activate checkstyle and add missing license headers
Delete also all "All rights reserved" statements, as they are
unnecessary and conflict with checkstyle's header check. Delete unused
imports.
2014-02-17 20:09:55 +01:00

1879 lines
74 KiB
Java

/**
*
* Copyright 2003-2007 Jive Software.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.muc;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.TimeZone;
import org.jivesoftware.smack.Chat;
import org.jivesoftware.smack.ChatManagerListener;
import org.jivesoftware.smack.Connection;
import org.jivesoftware.smack.ConnectionConfiguration;
import org.jivesoftware.smack.PacketCollector;
import org.jivesoftware.smack.SmackConfiguration;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.packet.IQ;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.Presence;
import org.jivesoftware.smack.packet.XMPPError;
import org.jivesoftware.smack.test.SmackTestCase;
import org.jivesoftware.smackx.Form;
import org.jivesoftware.smackx.FormField;
import org.jivesoftware.smackx.ServiceDiscoveryManager;
import org.jivesoftware.smackx.packet.DelayInformation;
import org.jivesoftware.smackx.packet.DiscoverInfo;
import org.jivesoftware.smackx.packet.XHTMLExtension;
/**
* Tests the new MUC functionalities.
*
* @author Gaston Dombiak
*/
public class MultiUserChatTest extends SmackTestCase {
private String room;
private MultiUserChat muc;
public MultiUserChatTest(String arg0) {
super(arg0);
}
/**
* Test the compatibility of the MUC service with clients that still use the old groupchat
* protocol.
*/
public void testGroupchatCompatibility() {
// TODO: this test needs to be re-written so that it manually emulates the old-style
// TODO: group chat protocol. Tne GroupChat class was deleted for Smack 3.0.
/*try {
Message message;
GroupChat groupchat = new GroupChat(getConnection(1), room);
groupchat.join("testbot2");
Thread.sleep(400);
// User1 checks the presence of user2 in the room
Presence presence = muc.getOccupantPresence(room + "/testbot2");
assertNotNull("Presence of user2 in room is missing", presence);
assertEquals(
"Presence mode of user2 is wrong",
Presence.Mode.available,
presence.getMode());
// User using old client send a message
groupchat.sendMessage("Hello");
// Check that the rest of the occupants (that are support MUC) received the message
message = muc.nextMessage(1000);
assertNotNull("A MUC client didn't receive the message from an old client", message);
// User that supports MUC send a message
muc.sendMessage("Bye");
// Check that the client the doesn't support MUC received the message
message = groupchat.nextMessage(1000);
assertNotNull("An old client didn't receive the message from a MUC client", message);
// User that doesn't support MUC leaves the room
groupchat.leave();
Thread.sleep(300);
// User1 checks the that user2 is not present in the room
Occupant occupant = muc.getOccupant(room + "/testbot2");
assertNull("Occupant testbot2 still exists", occupant);
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}*/
}
public void testDiscussionHistory() {
try {
// User1 sends some messages to the room
muc.sendMessage("Message 1");
muc.sendMessage("Message 2");
// Wait 5 seconds before sending the last message
Thread.sleep(5000);
muc.sendMessage("Message 3");
// User2 joins the room requesting to receive the messages of the last 2 seconds.
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
DiscussionHistory history = new DiscussionHistory();
history.setSeconds(2);
muc2.join("testbot2", null, history, SmackConfiguration.getPacketReplyTimeout());
Message msg;
// Get first historic message
msg = muc2.nextMessage(1000);
assertNotNull("First message is null", msg);
DelayInformation delay = (DelayInformation) msg.getExtension("x", "jabber:x:delay");
assertNotNull("Message contains no delay information", delay);
SimpleDateFormat UTC_FORMAT = new SimpleDateFormat("yyyyMMdd'T'HH:mm:ss");
UTC_FORMAT.setTimeZone(TimeZone.getDefault());
System.out.println(UTC_FORMAT.format(delay.getStamp()));
assertEquals("Body of first message is incorrect", "Message 3", msg.getBody());
// Try to get second historic message
msg = muc2.nextMessage(1000);
assertNull("Second message is not null", msg);
// User3 joins the room requesting to receive the last 2 messages.
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
history = new DiscussionHistory();
history.setMaxStanzas(2);
muc3.join("testbot3", null, history, SmackConfiguration.getPacketReplyTimeout());
// Get first historic message
msg = muc3.nextMessage(1000);
assertNotNull("First message is null", msg);
assertEquals("Body of first message is incorrect", "Message 2", msg.getBody());
// Get second historic message
msg = muc3.nextMessage(1000);
assertNotNull("Second message is null", msg);
assertEquals("Body of second message is incorrect", "Message 3", msg.getBody());
// Try to get third historic message
msg = muc3.nextMessage(1000);
assertNull("Third message is not null", msg);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testParticipantPresence() {
try {
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
Thread.sleep(400);
// User1 checks the presence of user2 in the room
Presence presence = muc.getOccupantPresence(room + "/testbot2");
assertNotNull("Presence of user2 in room is missing", presence);
assertTrue(
"Presence mode of user2 is wrong",
presence.getMode() == null || presence.getMode() == Presence.Mode.available);
// User2 changes his availability to AWAY
muc2.changeAvailabilityStatus("Gone to have lunch", Presence.Mode.away);
Thread.sleep(200);
// User1 checks the presence of user2 in the room
presence = muc.getOccupantPresence(room + "/testbot2");
assertNotNull("Presence of user2 in room is missing", presence);
assertEquals("Presence mode of user2 is wrong", Presence.Mode.away, presence.getMode());
assertEquals(
"Presence status of user2 is wrong",
"Gone to have lunch",
presence.getStatus());
// User2 changes his nickname
muc2.changeNickname("testbotII");
Thread.sleep(200);
// User1 checks the presence of user2 in the room
presence = muc.getOccupantPresence(room + "/testbot2");
assertNull("Presence of participant testbot2 still exists", presence);
presence = muc.getOccupantPresence(room + "/testbotII");
assertNotNull("Presence of participant testbotII does not exist", presence);
assertEquals(
"Presence of participant testbotII has a wrong from",
room + "/testbotII",
presence.getFrom());
// User2 leaves the room
muc2.leave();
Thread.sleep(250);
// User1 checks the presence of user2 in the room
presence = muc.getOccupantPresence(room + "/testbotII");
assertNull("Presence of participant testbotII still exists", presence);
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testAnonymousParticipant() {
try {
// Anonymous user joins the new room
ConnectionConfiguration connectionConfiguration =
new ConnectionConfiguration(getHost(), getPort(), getServiceName());
XMPPConnection anonConnection = new XMPPConnection(connectionConfiguration);
anonConnection.connect();
anonConnection.loginAnonymously();
MultiUserChat muc2 = new MultiUserChat(anonConnection, room);
muc2.join("testbot2");
Thread.sleep(400);
// User1 checks the presence of Anonymous user in the room
Presence presence = muc.getOccupantPresence(room + "/testbot2");
assertNotNull("Presence of user2 in room is missing", presence);
assertTrue(
"Presence mode of user2 is wrong",
presence.getMode() == null || presence.getMode() == Presence.Mode.available);
// Anonymous user leaves the room
muc2.leave();
anonConnection.disconnect();
Thread.sleep(250);
// User1 checks the presence of Anonymous user in the room
presence = muc.getOccupantPresence(room + "/testbot2");
assertNull("Presence of participant testbotII still exists", presence);
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testInvitation() {
final String[] answer = new String[2];
try {
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User3 is listening to MUC invitations
MultiUserChat.addInvitationListener(getConnection(2), new InvitationListener() {
public void invitationReceived(
Connection conn,
String room,
String inviter,
String reason,
String password,
Message message) {
// Indicate that the invitation was received
answer[0] = reason;
// Reject the invitation
MultiUserChat.decline(conn, room, inviter, "I'm busy right now");
}
});
// User2 is listening to invitation rejections
muc2.addInvitationRejectionListener(new InvitationRejectionListener() {
public void invitationDeclined(String invitee, String reason) {
// Indicate that the rejection was received
answer[1] = reason;
}
});
// User2 invites user3 to join to the room
muc2.invite(getFullJID(2), "Meet me in this excellent room");
Thread.sleep(350);
assertEquals(
"Invitation was not received",
"Meet me in this excellent room",
answer[0]);
assertEquals("Rejection was not received", "I'm busy right now", answer[1]);
// User2 leaves the room
muc2.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testInvitationWithMessage() {
final String[] answer = new String[2];
try {
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User3 is listening to MUC invitations
MultiUserChat.addInvitationListener(getConnection(2), new InvitationListener() {
public void invitationReceived(
Connection conn,
String room,
String inviter,
String reason,
String password,
Message message) {
// Indicate that the invitation was received
answer[0] = reason;
XHTMLExtension extension = (XHTMLExtension) message.getExtension("html",
"http://jabber.org/protocol/xhtml-im");
assertNotNull("An extension was not found in the invitation", extension);
answer[1] = (String) extension.getBodies().next();
}
});
// User2 invites user3 to join to the room
Message msg = new Message();
XHTMLExtension xhtmlExtension = new XHTMLExtension();
xhtmlExtension.addBody("<body>Meet me in this excellent room</body>");
msg.addExtension(xhtmlExtension);
muc2.invite(msg , getFullJID(2), "Meet me in this excellent room");
Thread.sleep(350);
assertEquals(
"Invitation was not received",
"Meet me in this excellent room",
answer[0]);
assertEquals("Rejection was not received",
"<body>Meet me in this excellent room</body>", answer[1]);
// User2 leaves the room
muc2.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testDiscoverJoinedRooms() {
try {
// Check that user1 has joined only to one room
Iterator<String> joinedRooms = MultiUserChat.getJoinedRooms(getConnection(1), getFullJID(0));
assertTrue("Joined rooms shouldn't be empty", joinedRooms.hasNext());
assertEquals("Joined room is incorrect", joinedRooms.next(), room);
assertFalse("User has joined more than one room", joinedRooms.hasNext());
// Leave the new room
muc.leave();
// Check that user1 is not currently join any room
joinedRooms = MultiUserChat.getJoinedRooms(getConnection(1), getFullJID(0));
assertFalse("Joined rooms should be empty", joinedRooms.hasNext());
muc.join("testbot");
}
catch (XMPPException e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testDiscoverMUCSupport() {
// Discover user1 support of MUC
boolean supports = MultiUserChat.isServiceEnabled(getConnection(1), getFullJID(0));
assertTrue("Couldn't detect that user1 supports MUC", supports);
}
public void testDiscoverRoomInfo() {
try {
makeRoomModerated();
RoomInfo info = MultiUserChat.getRoomInfo(getConnection(1), room);
assertFalse("Room is members-only", info.isMembersOnly());
assertTrue("Room is moderated", info.isModerated());
assertFalse("Room is Nonanonymous", info.isNonanonymous());
assertFalse("Room is PasswordProtected", info.isPasswordProtected());
assertFalse("Room is Persistent", info.isPersistent());
assertEquals("Room's description is incorrect", "fruta124", info.getDescription());
assertEquals("Room's subject is incorrect", "", info.getSubject());
assertEquals("Number of occupants is incorrect", 1, info.getOccupantsCount());
}
catch (XMPPException e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testDiscoverMUCService() {
try {
Collection<String> services = MultiUserChat.getServiceNames(getConnection(1));
assertFalse("No MUC service was found", services.isEmpty());
// Discover the hosted rooms by the chat service.
Collection<HostedRoom> rooms = MultiUserChat.getHostedRooms(getConnection(1),
services.toArray(new String[0])[0]);
// Check that we have discovered the room used by this test
assertFalse("No room was found", rooms.isEmpty());
// Check that we have discovered the room used by this test
boolean found = false;
for (Object room1 : rooms) {
HostedRoom hostedRoom = (HostedRoom) room1;
if (room.equals(hostedRoom.getJid())) {
found = true;
break;
}
}
assertTrue("JID of room was not found", found);
}
catch (XMPPException e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testPrivateChat() {
try {
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
getConnection(0).getChatManager().addChatListener(new ChatManagerListener() {
public void chatCreated(Chat chat2, boolean createdLocally) {
assertEquals(
"Sender of chat is incorrect",
room + "/testbot2",
chat2.getParticipant());
try {
chat2.sendMessage("ACK");
}
catch (XMPPException e) {
fail(e.getMessage());
}
}
});
// Start a private chat with another participant
Chat chat = muc2.createPrivateChat(room + "/testbot", null);
PacketCollector collector = chat.createCollector();
chat.sendMessage("Hello there");
Message response = (Message) collector.nextResult(2000);
assertNotNull("No response", response);
assertEquals("Sender of response is incorrect", room + "/testbot", response.getFrom());
assertEquals("Body of response is incorrect", "ACK", response.getBody());
// User2 leaves the room
muc2.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
/**
* Tests that IQ packets can be sent to/from room occupants. This case will try to discover
* information about other room occupants.
*/
public void testPrivateIQ() {
try {
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User2 discovers information about User1
DiscoverInfo info = ServiceDiscoveryManager.getInstanceFor(getConnection(1))
.discoverInfo(room + "/testbot", null);
assertNotNull("No info was discovered from room occupant", info);
assertEquals("Wrong IQ type", IQ.Type.RESULT, info.getType());
assertEquals("Wrong IQ sender", room + "/testbot", info.getFrom());
// User2 leaves the room
muc2.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testReservedNickname() {
try {
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
// Check that user2 doesn't have a reserved nickname yet
String reservedNickname = muc2.getReservedNickname();
assertNull("Reserved nickname is not null", reservedNickname);
// User2 registers with the room and reserves a nickname
Form registrationForm = muc2.getRegistrationForm();
Form answerForm = registrationForm.createAnswerForm();
answerForm.setAnswer("muc#register_first", "MyFirstName");
answerForm.setAnswer("muc#register_last", "MyLastName");
answerForm.setAnswer("muc#register_roomnick", "MyNick");
muc2.sendRegistrationForm(answerForm);
// Check that user2 has a reserved nickname
reservedNickname = muc2.getReservedNickname();
assertEquals("Reserved nickname is wrong", "MyNick", reservedNickname);
// Check that user2 can join the room using his reserved nickname
muc2.join("MyNick");
muc2.leave();
// Check that other users cannot join the room with user2's reserved nickname
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
try {
muc3.join("MyNick");
fail("Other user was able to join with other user's reserved nickname");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull(
"No XMPPError was received when joining with other user's reserved nickname",
xmppError);
assertEquals(
"Different error code was received while joining with other user's reserved nickname",
409,
xmppError.getCode());
}
// Check that user3 can join the room using his own nickname (not reserved)
muc3.join("MyNotReservedNick");
muc3.leave();
// Check that another user cannot reserve an already reserved nickname
registrationForm = muc3.getRegistrationForm();
answerForm = registrationForm.createAnswerForm();
answerForm.setAnswer("muc#register_first", "MyFirstName 2");
answerForm.setAnswer("muc#register_last", "MyLastName 2");
answerForm.setAnswer("muc#register_roomnick", "MyNick");
try {
muc3.sendRegistrationForm(answerForm);
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull(
"No XMPPError was received when reserving an already reserved nickname",
xmppError);
assertEquals(
"Different error code was received while reserving an already reserved nickname",
409,
xmppError.getCode());
}
// Check that another user can reserve a new nickname
registrationForm = muc3.getRegistrationForm();
answerForm = registrationForm.createAnswerForm();
answerForm.setAnswer("muc#register_first", "MyFirstName 2");
answerForm.setAnswer("muc#register_last", "MyLastName 2");
answerForm.setAnswer("muc#register_roomnick", "MyNick 2");
muc3.sendRegistrationForm(answerForm);
}
catch (XMPPException e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testChangeSubject() {
final String[] answer = new String[2];
try {
// User1 sets an initial subject
muc.changeSubject("Initial Subject");
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User3 joins the new room
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// User3 wants to be notified every time the room's subject is changed.
muc3.addSubjectUpdatedListener(new SubjectUpdatedListener() {
public void subjectUpdated(String subject, String from) {
answer[0] = subject;
answer[1] = from;
}
});
// Check that a 403 error is received when a not allowed user tries to change the
// subject in a room
try {
muc2.changeSubject("New Subject2");
fail("User2 was allowed to change the room's subject");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull(
"No XMPPError was received when changing the room's subject",
xmppError);
assertEquals(
"Different error code was received while changing the room's subject",
403,
xmppError.getCode());
}
// Check that every MUC updates its subject when an allowed user changes the subject
// in a room
muc.changeSubject("New Subject1");
Thread.sleep(300);
// Check that User2's MUC has updated its subject
assertEquals(
"User2 didn't receive the subject notification",
"New Subject1",
muc2.getSubject());
// Check that SubjectUpdatedListener is working OK
assertEquals(
"User3 didn't receive the subject notification",
"New Subject1",
answer[0]);
assertEquals(
"User3 didn't receive the correct user that changed the subject",
room + "/testbot",
answer[1]);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testKickParticipant() {
final String[] answer = new String[3];
try {
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User2 will lister for his own "kicking"
muc2.addUserStatusListener(new DefaultUserStatusListener() {
public void kicked(String actor, String reason) {
super.kicked(actor, reason);
answer[0] = actor;
answer[1] = reason;
}
});
// User3 joins the new room
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// User3 will lister for user2's "kicking"
muc3.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void kicked(String participant, String actor, String reason) {
super.kicked(participant, actor, reason);
answer[2] = participant;
}
});
try {
// Check whether a simple participant can kick a room owner or not
muc2.kickParticipant("testbot", "Because I'm bad");
fail("User2 was able to kick a room owner");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull("No XMPPError was received when kicking a room owner", xmppError);
assertEquals(
"A simple participant was able to kick another participant from the room",
403,
xmppError.getCode());
}
// Check that the room's owner can kick a simple participant
muc.kickParticipant("testbot2", "Because I'm the owner");
Thread.sleep(300);
assertNull(
"User2 wasn't kicked from the room",
muc.getOccupant(room + "/testbot2"));
assertFalse("User2 thinks that he's still in the room", muc2.isJoined());
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the correct initiator of the kick",
getBareJID(0),
answer[0]);
assertEquals(
"User2 didn't receive the correct reason for the kick",
"Because I'm the owner",
answer[1]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive the correct kicked participant",
room + "/testbot2",
answer[2]);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testBanUser() {
final String[] answer = new String[3];
try {
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User2 will lister for his own "banning"
muc2.addUserStatusListener(new DefaultUserStatusListener() {
public void banned(String actor, String reason) {
super.banned(actor, reason);
answer[0] = actor;
answer[1] = reason;
}
});
// User3 joins the new room
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// User3 will lister for user2's "banning"
muc3.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void banned(String participant, String actor, String reason) {
super.banned(participant, actor, reason);
answer[2] = participant;
}
});
try {
// Check whether a simple participant can ban a room owner or not
muc2.banUser(getBareJID(0), "Because I'm bad");
fail("User2 was able to ban a room owner");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull("No XMPPError was received when banning a room owner", xmppError);
assertEquals(
"A simple participant was able to ban another participant from the room",
403,
xmppError.getCode());
}
// Check that the room's owner can ban a simple participant
muc.banUser(getBareJID(1), "Because I'm the owner");
Thread.sleep(300);
assertNull(
"User2 wasn't banned from the room",
muc.getOccupant(room + "/testbot2"));
assertFalse("User2 thinks that he's still in the room", muc2.isJoined());
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the correct initiator of the ban",
getBareJID(0),
answer[0]);
assertEquals(
"User2 didn't receive the correct reason for the banning",
"Because I'm the owner",
answer[1]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive the correct banned JID",
room + "/testbot2",
answer[2]);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testVoice() {
final String[] answer = new String[4];
try {
makeRoomModerated();
// User2 joins the new room (as a visitor)
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User2 will listen for his own "voice"
muc2.addUserStatusListener(new DefaultUserStatusListener() {
public void voiceGranted() {
super.voiceGranted();
answer[0] = "canSpeak";
}
public void voiceRevoked() {
super.voiceRevoked();
answer[1] = "cannot speak";
}
});
// User3 joins the new room (as a visitor)
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// User3 will lister for user2's "voice"
muc3.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void voiceGranted(String participant) {
super.voiceGranted(participant);
answer[2] = participant;
}
public void voiceRevoked(String participant) {
super.voiceRevoked(participant);
answer[3] = participant;
}
});
try {
// Check whether a visitor can grant voice to another visitor
muc2.grantVoice("testbot3");
fail("User2 was able to grant voice");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull("No XMPPError was received granting voice", xmppError);
assertEquals(
"A visitor was able to grant voice to another visitor",
403,
xmppError.getCode());
}
// Check that the room's owner can grant voice to a participant
muc.grantVoice("testbot2");
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the grant voice notification",
"canSpeak",
answer[0]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's grant voice notification",
room + "/testbot2",
answer[2]);
// Check that the room's owner can revoke voice from a participant
muc.revokeVoice("testbot2");
Thread.sleep(300);
assertEquals(
"User2 didn't receive the revoke voice notification",
"cannot speak",
answer[1]);
assertEquals(
"User3 didn't receive user2's revoke voice notification",
room + "/testbot2",
answer[3]);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testModerator() {
final String[] answer = new String[8];
try {
makeRoomModerated();
// User2 joins the new room (as a visitor)
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User2 will listen for moderator privileges
muc2.addUserStatusListener(new DefaultUserStatusListener() {
public void voiceGranted() {
super.voiceGranted();
answer[0] = "canSpeak";
}
public void voiceRevoked() {
super.voiceRevoked();
answer[1] = "cannot speak";
}
public void moderatorGranted() {
super.moderatorGranted();
answer[4] = "I'm a moderator";
}
public void moderatorRevoked() {
super.moderatorRevoked();
answer[5] = "I'm not a moderator";
}
});
// User3 joins the new room (as a visitor)
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// User3 will lister for user2's moderator privileges
muc3.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void voiceGranted(String participant) {
super.voiceGranted(participant);
answer[2] = participant;
}
public void voiceRevoked(String participant) {
super.voiceRevoked(participant);
answer[3] = participant;
}
public void moderatorGranted(String participant) {
super.moderatorGranted(participant);
answer[6] = participant;
}
public void moderatorRevoked(String participant) {
super.moderatorRevoked(participant);
answer[7] = participant;
}
});
try {
// Check whether a visitor can grant moderator privileges to another visitor
muc2.grantModerator("testbot3");
fail("User2 was able to grant moderator privileges");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull("No XMPPError was received granting moderator privileges", xmppError);
assertEquals(
"A visitor was able to grant moderator privileges to another visitor",
403,
xmppError.getCode());
}
// Check that the room's owner can grant moderator privileges to a visitor
muc.grantModerator("testbot2");
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the grant voice notification",
"canSpeak",
answer[0]);
assertEquals(
"User2 didn't receive the grant moderator privileges notification",
"I'm a moderator",
answer[4]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's grant voice notification",
room + "/testbot2",
answer[2]);
assertEquals(
"User3 didn't receive user2's grant moderator privileges notification",
room + "/testbot2",
answer[6]);
// Check that the room's owner can revoke moderator privileges from a moderator
muc.revokeModerator("testbot2");
Thread.sleep(300);
assertNull("User2 received a false revoke voice notification", answer[1]);
assertNull("User3 received a false user2's voice privileges notification", answer[3]);
assertEquals(
"User2 didn't receive the revoke moderator privileges notification",
"I'm not a moderator",
answer[5]);
assertEquals(
"User3 didn't receive user2's revoke moderator privileges notification",
room + "/testbot2",
answer[7]);
// Check that the room's owner can grant moderator privileges to a participant
clearAnswer(answer);
muc.grantModerator("testbot2");
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertNull("User2 received a false grant voice notification", answer[0]);
assertEquals(
"User2 didn't receive the grant moderator privileges notification",
"I'm a moderator",
answer[4]);
// Check that ParticipantStatusListener is working OK
assertNull("User3 received a false user2's grant voice notification", answer[2]);
assertEquals(
"User3 didn't receive user2's grant moderator privileges notification",
room + "/testbot2",
answer[6]);
// Check that the room's owner can revoke voice from a moderator
clearAnswer(answer);
muc.revokeVoice("testbot2");
Thread.sleep(300);
assertEquals(
"User2 didn't receive the revoke voice notification",
"cannot speak",
answer[1]);
assertEquals(
"User3 didn't receive user2's revoke voice notification",
room + "/testbot2",
answer[3]);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testMembership() {
final String[] answer = new String[4];
try {
makeRoomModerated();
// User2 joins the new room (as a visitor)
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User2 will listen for membership privileges
muc2.addUserStatusListener(new DefaultUserStatusListener() {
public void membershipGranted() {
super.membershipGranted();
answer[0] = "I'm a member";
}
public void membershipRevoked() {
super.membershipRevoked();
answer[1] = "I'm not a member";
}
});
// User3 joins the new room (as a visitor)
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// User3 will lister for user2's membership privileges
muc3.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void membershipGranted(String participant) {
super.membershipGranted(participant);
answer[2] = participant;
}
public void membershipRevoked(String participant) {
super.membershipRevoked(participant);
answer[3] = participant;
}
});
try {
// Check whether a visitor can grant membership privileges to another visitor
muc2.grantMembership(getBareJID(2));
fail("User2 was able to grant membership privileges");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull(
"No XMPPError was received granting membership privileges",
xmppError);
assertEquals(
"A visitor was able to grant membership privileges to another visitor",
403,
xmppError.getCode());
}
// Check that the room's owner can grant membership privileges to a visitor
muc.grantMembership(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the grant membership notification",
"I'm a member",
answer[0]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's grant membership notification",
room + "/testbot2",
answer[2]);
// Check that the room's owner can revoke membership privileges from a member
// and make the occupant a visitor
muc.revokeMembership(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke membership notification",
"I'm not a member",
answer[1]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke membership notification",
room + "/testbot2",
answer[3]);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testAdmin() {
final String[] answer = new String[8];
try {
makeRoomModerated();
// User2 joins the new room (as a visitor)
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User2 will listen for admin privileges
muc2.addUserStatusListener(new DefaultUserStatusListener() {
public void membershipGranted() {
super.membershipGranted();
answer[0] = "I'm a member";
}
public void membershipRevoked() {
super.membershipRevoked();
answer[1] = "I'm not a member";
}
public void adminGranted() {
super.adminGranted();
answer[2] = "I'm an admin";
}
public void adminRevoked() {
super.adminRevoked();
answer[3] = "I'm not an admin";
}
});
// User3 joins the new room (as a visitor)
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// User3 will lister for user2's admin privileges
muc3.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void membershipGranted(String participant) {
super.membershipGranted(participant);
answer[4] = participant;
}
public void membershipRevoked(String participant) {
super.membershipRevoked(participant);
answer[5] = participant;
}
public void adminGranted(String participant) {
super.adminGranted(participant);
answer[6] = participant;
}
public void adminRevoked(String participant) {
super.adminRevoked(participant);
answer[7] = participant;
}
});
try {
// Check whether a visitor can grant admin privileges to another visitor
muc2.grantAdmin(getBareJID(2));
fail("User2 was able to grant admin privileges");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull("No XMPPError was received granting admin privileges", xmppError);
assertEquals(
"A visitor was able to grant admin privileges to another visitor",
403,
xmppError.getCode());
}
// Check that the room's owner can grant admin privileges to a visitor
muc.grantAdmin(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the grant admin notification",
"I'm an admin",
answer[2]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's grant admin notification",
room + "/testbot2",
answer[6]);
// Check that the room's owner can revoke admin privileges from an admin
// and make the occupant a visitor
muc.revokeMembership(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke admin notification",
"I'm not an admin",
answer[3]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke admin notification",
room + "/testbot2",
answer[7]);
// Check that the room's owner can grant admin privileges to a member
clearAnswer(answer);
muc.grantMembership(getBareJID(1));
Thread.sleep(300);
muc.grantAdmin(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke membership notification",
"I'm not a member",
answer[1]);
assertEquals(
"User2 didn't receive the grant admin notification",
"I'm an admin",
answer[2]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke membership notification",
room + "/testbot2",
answer[5]);
assertEquals(
"User3 didn't receive user2's grant admin notification",
room + "/testbot2",
answer[6]);
// Check that the room's owner can revoke admin privileges from an admin
// and make the occupant a member
clearAnswer(answer);
muc.revokeAdmin(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke admin notification",
"I'm not an admin",
answer[3]);
assertEquals(
"User2 didn't receive the grant membership notification",
"I'm a member",
answer[0]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke admin notification",
room + "/testbot2",
answer[7]);
assertEquals(
"User3 didn't receive user2's grant membership notification",
room + "/testbot2",
answer[4]);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testOwnership() {
final String[] answer = new String[12];
try {
makeRoomModerated();
// User2 joins the new room (as a visitor)
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User2 will listen for ownership privileges
muc2.addUserStatusListener(new DefaultUserStatusListener() {
public void membershipGranted() {
super.membershipGranted();
answer[0] = "I'm a member";
}
public void membershipRevoked() {
super.membershipRevoked();
answer[1] = "I'm not a member";
}
public void adminGranted() {
super.adminGranted();
answer[2] = "I'm an admin";
}
public void adminRevoked() {
super.adminRevoked();
answer[3] = "I'm not an admin";
}
public void ownershipGranted() {
super.ownershipGranted();
answer[4] = "I'm an owner";
}
public void ownershipRevoked() {
super.ownershipRevoked();
answer[5] = "I'm not an owner";
}
});
// User3 joins the new room (as a visitor)
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// User3 will lister for user2's ownership privileges
muc3.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void membershipGranted(String participant) {
super.membershipGranted(participant);
answer[6] = participant;
}
public void membershipRevoked(String participant) {
super.membershipRevoked(participant);
answer[7] = participant;
}
public void adminGranted(String participant) {
super.adminGranted(participant);
answer[8] = participant;
}
public void adminRevoked(String participant) {
super.adminRevoked(participant);
answer[9] = participant;
}
public void ownershipGranted(String participant) {
super.ownershipGranted(participant);
answer[10] = participant;
}
public void ownershipRevoked(String participant) {
super.ownershipRevoked(participant);
answer[11] = participant;
}
});
try {
// Check whether a visitor can grant ownership privileges to another visitor
muc2.grantOwnership(getBareJID(2));
fail("User2 was able to grant ownership privileges");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull("No XMPPError was received granting ownership privileges", xmppError);
assertEquals(
"A visitor was able to grant ownership privileges to another visitor",
403,
xmppError.getCode());
}
// Check that the room's owner can grant ownership privileges to a visitor
muc.grantOwnership(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the grant ownership notification",
"I'm an owner",
answer[4]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's grant ownership notification",
room + "/testbot2",
answer[10]);
// Check that the room's owner can revoke ownership privileges from an owner
// and make the occupant a visitor
muc.revokeMembership(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke ownership notification",
"I'm not an owner",
answer[5]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke ownership notification",
room + "/testbot2",
answer[11]);
// Check that the room's owner can grant ownership privileges to a member
clearAnswer(answer);
muc.grantMembership(getBareJID(1));
Thread.sleep(300);
muc.grantOwnership(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke membership notification",
"I'm not a member",
answer[1]);
assertEquals(
"User2 didn't receive the grant ownership notification",
"I'm an owner",
answer[4]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke membership notification",
room + "/testbot2",
answer[7]);
assertEquals(
"User3 didn't receive user2's grant ownership notification",
room + "/testbot2",
answer[10]);
// Check that the room's owner can revoke ownership privileges from an owner
// and make the occupant a member
clearAnswer(answer);
muc.revokeAdmin(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke ownership notification",
"I'm not an owner",
answer[5]);
assertEquals(
"User2 didn't receive the grant membership notification",
"I'm a member",
answer[0]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke ownership notification",
room + "/testbot2",
answer[11]);
assertEquals(
"User3 didn't receive user2's grant membership notification",
room + "/testbot2",
answer[6]);
// Check that the room's owner can grant ownership privileges to an admin
clearAnswer(answer);
muc.grantAdmin(getBareJID(1));
Thread.sleep(300);
muc.grantOwnership(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke admin notification",
"I'm not an admin",
answer[3]);
assertEquals(
"User2 didn't receive the grant ownership notification",
"I'm an owner",
answer[4]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke admin notification",
room + "/testbot2",
answer[9]);
assertEquals(
"User3 didn't receive user2's grant ownership notification",
room + "/testbot2",
answer[10]);
// Check that the room's owner can revoke ownership privileges from an owner
// and make the occupant an admin
clearAnswer(answer);
muc.revokeOwnership(getBareJID(1));
Thread.sleep(300);
// Check that UserStatusListener is working OK
assertEquals(
"User2 didn't receive the revoke ownership notification",
"I'm not an owner",
answer[5]);
assertEquals(
"User2 didn't receive the grant admin notification",
"I'm an admin",
answer[2]);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User3 didn't receive user2's revoke ownership notification",
room + "/testbot2",
answer[11]);
assertEquals(
"User3 didn't receive user2's grant admin notification",
room + "/testbot2",
answer[8]);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testGetAffiliationList() {
try {
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User3 joins the new room
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
// Grant ownership privileges to user2
muc.grantOwnership(getBareJID(1));
// Grant moderator privileges to user3
muc.grantModerator("testbot3");
// Check that the owner list is correct
Collection<Affiliate> affiliates = muc.getOwners();
assertEquals("Room does not have 2 owners", 2, affiliates.size());
for (Affiliate affiliate1 : affiliates) {
if (getBareJID(0).equals(affiliate1.getJid())) {
assertEquals("Wrong affiliation", "owner", affiliate1.getAffiliation());
assertEquals("Wrong role", "moderator", affiliate1.getRole());
assertEquals("Wrong nick", "testbot", affiliate1.getNick());
}
else if (getBareJID(1).equals(affiliate1.getJid())) {
assertEquals("Wrong affiliation", "owner", affiliate1.getAffiliation());
assertEquals("Wrong role", "moderator", affiliate1.getRole());
assertEquals("Wrong nick", "testbot2", affiliate1.getNick());
}
else {
fail("Unknown owner " + affiliate1.getJid());
}
}
// Check that the admin list is correct
affiliates = muc.getAdmins();
assertEquals("Room has admins", 0, affiliates.size());
// Check that the members list is correct
affiliates = muc.getMembers();
assertEquals("Room has admins", 0, affiliates.size());
// Grant membership privileges to user2
muc.grantMembership(getBareJID(1));
// Check that the members list is correct
affiliates = muc.getMembers();
assertEquals("Room has admins", 1, affiliates.size());
Affiliate affiliate = (Affiliate) affiliates.iterator().next();
assertEquals("Wrong member jid", getBareJID(1), affiliate.getJid());
// Check that the members list is correct
affiliates = muc.getOutcasts();
assertEquals("Room has outcasts", 0, affiliates.size());
// Check that the moderator list is correct
Collection<Occupant> occupants = muc.getModerators();
assertEquals("Room does not have 2 moderators", 2, occupants.size());
for (Occupant occupant1 : occupants) {
if (getFullJID(0).equals(occupant1.getJid())) {
assertEquals("Wrong affiliation", "owner", occupant1.getAffiliation());
assertEquals("Wrong role", "moderator", occupant1.getRole());
assertEquals("Wrong nick", "testbot", occupant1.getNick());
}
else if (getFullJID(2).equals(occupant1.getJid())) {
assertEquals("Wrong affiliation", "none", occupant1.getAffiliation());
assertEquals("Wrong role", "moderator", occupant1.getRole());
assertEquals("Wrong nick", "testbot3", occupant1.getNick());
}
else {
fail("Unknown moderator " + occupant1.getJid());
}
}
// Check that the participants list is correct
occupants = muc.getParticipants();
assertEquals("Room does not have 1 participant", 1, occupants.size());
Occupant occupant = (Occupant) occupants.iterator().next();
assertEquals("Wrong participant jid", getFullJID(1), occupant.getJid());
Thread.sleep(500);
// Check that we can retrieve Occupant information of a given user
occupant = muc.getOccupant(room + "/testbot2");
assertNotNull("Occupant was not found", occupant);
assertEquals("Wrong occupant jid", getFullJID(1), occupant.getJid());
assertEquals("Wrong occupant affiliation", "member", occupant.getAffiliation());
assertEquals("Wrong occupant role", "participant", occupant.getRole());
assertEquals("Wrong occupant nick", "testbot2", occupant.getNick());
try {
// Check whether a member can get the list of owners
muc2.getOwners();
fail("User2 was able to get the list of owners");
}
catch (XMPPException e) {
XMPPError xmppError = e.getXMPPError();
assertNotNull("No XMPPError was received getting the list of owners", xmppError);
assertEquals(
"A member was able to get the list of owners",
403,
xmppError.getCode());
}
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
/**
* Check that ParticipantStatusListener is receiving joining and leaving events correctly.
*/
public void testJoinLeftEvents() {
final String[] answer = new String[8];
try {
// User1 will listen for occupants joining and leaving the room
muc.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void joined(String participant) {
super.joined(participant);
if ((room + "/testbot2").equals(participant)) {
answer[0] = participant;
}
else {
answer[1] = participant;
}
}
public void left(String participant) {
super.left(participant);
if ((room + "/testbot2").equals(participant)) {
answer[2] = participant;
}
// Skip unavailable presences of the same user
else if (!(room + "/testbot").equals(participant)) {
answer[3] = participant;
}
}
});
// User2 joins the new room
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
// User2 will listen for User3 joining and leaving the room
muc2.addParticipantStatusListener(new DefaultParticipantStatusListener() {
public void joined(String participant) {
super.joined(participant);
if ((room + "/testbot").equals(participant)) {
answer[4] = participant;
}
else {
answer[5] = participant;
}
}
public void left(String participant) {
super.left(participant);
if ((room + "/testbot").equals(participant)) {
answer[6] = participant;
}
// Skip unavailable presences of the same user
else if (!(room + "/testbot2").equals(participant)){
answer[7] = participant;
}
}
});
muc2.join("testbot2");
// User3 joins the new room
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.join("testbot3");
Thread.sleep(150);
// User3 leaves the room
muc3.leave();
Thread.sleep(150);
// User2 leaves the room
muc2.leave();
Thread.sleep(250);
// Check that ParticipantStatusListener is working OK
assertEquals(
"User1 didn't receive the event of User2 joining the room",
room + "/testbot2",
answer[0]);
assertEquals(
"User1 didn't receive the event of User3 joining the room",
room + "/testbot3",
answer[1]);
assertEquals(
"User1 didn't receive the event of User2 leaving the room",
room + "/testbot2",
answer[2]);
assertEquals(
"User1 didn't receive the event of User3 leaving the room",
room + "/testbot3",
answer[3]);
assertEquals(
"User2 didn't receive the event of User1 joining the room",
room + "/testbot",
answer[4]);
assertEquals(
"User2 didn't receive the event of User3 joining the room",
room + "/testbot3",
answer[5]);
assertNull(
"User2 received the event of User1 leaving the room",
answer[6]);
assertEquals(
"User2 didn't receive the event of User3 leaving the room",
room + "/testbot3",
answer[7]);
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testManyResources() throws Exception {
// Create 5 more connections for user2
XMPPConnection[] conns = new XMPPConnection[5];
for (int i = 0; i < conns.length; i++) {
ConnectionConfiguration connectionConfiguration =
new ConnectionConfiguration(getHost(), getPort(), getServiceName());
connectionConfiguration.setSecurityMode(ConnectionConfiguration.SecurityMode.disabled);
conns[i] = new XMPPConnection(connectionConfiguration);
conns[i].connect();
conns[i].login(getUsername(1), getPassword(1), "resource-" + i);
Thread.sleep(20);
}
// Join the 5 connections to the same room
MultiUserChat[] mucs = new MultiUserChat[5];
for (int i = 0; i < mucs.length; i++) {
mucs[i] = new MultiUserChat(conns[i], room);
mucs[i].join("resource-" + i);
}
Thread.sleep(200);
// Each connection has something to say
for (int i = 0; i < mucs.length; i++) {
mucs[i].sendMessage("I'm resource-" + i);
}
Thread.sleep(200);
// Each connection leaves the room and closes the connection
for (MultiUserChat muc1 : mucs) {
muc1.leave();
}
Thread.sleep(200);
for (int i = 0; i < mucs.length; i++) {
conns[i].disconnect();
}
}
/**
* Test that deaf occupants do not get broadcasted messages. Deaf occupants is a Jive
* extension to MUC so it may not work with other servers.
*/
public void testDeafOccupants() {
try {
// User2 joins the room as a "normal" occupant
MultiUserChat muc2 = new MultiUserChat(getConnection(1), room);
muc2.join("testbot2");
// User3 joins the room as a "deaf" occupant
MultiUserChat muc3 = new MultiUserChat(getConnection(2), room);
muc3.addPresenceInterceptor(new DeafOccupantInterceptor());
muc3.join("testbot3");
// User1 sends some messages to the room
muc.sendMessage("Message 1");
muc.sendMessage("Message 2");
Thread.sleep(500);
Message msg;
// Normal occupant gets first message
msg = muc2.nextMessage(1000);
assertNotNull("First message is null", msg);
// Get second message
msg = muc2.nextMessage(1000);
assertNotNull("Second message is null", msg);
// Try to get a third message
msg = muc2.nextMessage(1000);
assertNull("Third message is not null", msg);
// Deaf occupant tries to get a third message
msg = muc3.nextMessage(1000);
assertNull("Deaf occupant got a broadcast message", msg);
// User2 leaves the room
muc2.leave();
// User3 leaves the room
muc3.leave();
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
private void makeRoomModerated() throws XMPPException {
// User1 (which is the room owner) converts the instant room into a moderated room
Form form = muc.getConfigurationForm();
Form answerForm = form.createAnswerForm();
answerForm.setAnswer("muc#roomconfig_moderatedroom", true);
answerForm.setAnswer("muc#roomconfig_whois", Arrays.asList("moderators"));
// Keep the room owner
try {
List<String> owners = new ArrayList<String>();
owners.add(getBareJID(0));
answerForm.setAnswer("muc#roomconfig_roomowners", owners);
}
catch (IllegalArgumentException e) {
// Do nothing
}
muc.sendConfigurationForm(answerForm);
}
private void clearAnswer(String[] answer) {
for (int i = 0; i < answer.length; i++) {
answer[i] = null;
}
}
protected void setUp() throws Exception {
//XMPPConnection.DEBUG_ENABLED = false;
super.setUp();
room = "fruta124@" + getMUCDomain();
try {
// User1 creates the room
muc = new MultiUserChat(getConnection(0), room);
muc.create("testbot");
// User1 sends an empty room configuration form which indicates that we want
// an instant room
Form form = new Form(Form.TYPE_SUBMIT);
FormField field = new FormField("muc#roomconfig_whois");
field.setType("list-single");
form.addField(field);
form.setAnswer("muc#roomconfig_whois", Arrays.asList("moderators"));
muc.sendConfigurationForm(form);
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
protected void tearDown() throws Exception {
// Destroy the new room
muc.destroy("The room has almost no activity...", null);
super.tearDown();
}
protected int getMaxConnections() {
return 3;
}
}