Prefix subprojects with 'smack-'

instead of using the old baseName=smack appendix=project.name approach,
we are now going convention over configuration and renaming the
subprojects directories to the proper name.

Having a prefix is actually very helpful, because the resulting
libraries will be named like the subproject. And a core-4.0.0-rc1.jar is
not as explicit about what it actually *is* as a
smack-core-4.0.0-rc1.jar.

SMACK-265

smack-core/src/integration-test/java/org/jivesoftware/smack/ChatTest.java

@@ -0,0 +1,95 @@
+/**
+ *
+ * Copyright 2004 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.smack;
+
+import java.util.Date;
+
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.jivesoftware.smack.filter.ThreadFilter;
+
+
+/**
+ * Tests the chat functionality.
+ *
+ * @author Gaston Dombiak
+ */
+public class ChatTest extends SmackTestCase {
+
+    public ChatTest(String arg0) {
+        super(arg0);
+    }
+
+    public void testProperties() {
+        try {
+            Chat newChat = getConnection(0).getChatManager().createChat(getFullJID(1), null);
+            PacketCollector collector = getConnection(1)
+                    .createPacketCollector(new ThreadFilter(newChat.getThreadID()));
+
+            Message msg = new Message();
+
+            msg.setSubject("Subject of the chat");
+            msg.setBody("Body of the chat");
+            msg.setProperty("favoriteColor", "red");
+            msg.setProperty("age", 30);
+            msg.setProperty("distance", 30f);
+            msg.setProperty("weight", 30d);
+            msg.setProperty("male", true);
+            msg.setProperty("birthdate", new Date());
+            newChat.sendMessage(msg);
+
+            Message msg2 = (Message) collector.nextResult(2000);
+
+            assertNotNull("No message was received", msg2);
+            assertEquals("Subjects are different", msg.getSubject(), msg2.getSubject());
+            assertEquals("Bodies are different", msg.getBody(), msg2.getBody());
+            assertEquals(
+                    "favoriteColors are different",
+                    msg.getProperty("favoriteColor"),
+                    msg2.getProperty("favoriteColor"));
+            assertEquals(
+                    "ages are different",
+                    msg.getProperty("age"),
+                    msg2.getProperty("age"));
+            assertEquals(
+                    "distances are different",
+                    msg.getProperty("distance"),
+                    msg2.getProperty("distance"));
+            assertEquals(
+                    "weights are different",
+                    msg.getProperty("weight"),
+                    msg2.getProperty("weight"));
+            assertEquals(
+                    "males are different",
+                    msg.getProperty("male"),
+                    msg2.getProperty("male"));
+            assertEquals(
+                    "birthdates are different",
+                    msg.getProperty("birthdate"),
+                    msg2.getProperty("birthdate"));
+        }
+        catch (XMPPException e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    protected int getMaxConnections() {
+        return 2;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/FloodTest.java

@@ -0,0 +1,103 @@
+/**
+ *
+ * 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.smack;
+
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.jivesoftware.smack.filter.ThreadFilter;
+
+/**
+ * Simple test to measure server performance.
+ *
+ * @author Gaston Dombiak
+ */
+public class FloodTest extends SmackTestCase {
+
+    public FloodTest(String arg0) {
+        super(arg0);
+    }
+
+    public void testMessageFlood() {
+        try {
+            Chat chat11 = getConnection(0).getChatManager().createChat(getBareJID(1), null);
+            PacketCollector chat12 = getConnection(1).createPacketCollector(
+                    new ThreadFilter(chat11.getThreadID()));
+
+            Chat chat21 = getConnection(0).getChatManager().createChat(getBareJID(2), null);
+            PacketCollector chat22 = getConnection(2).createPacketCollector(
+                    new ThreadFilter(chat21.getThreadID()));
+
+            Chat chat31 = getConnection(0).getChatManager().createChat(getBareJID(3), null);
+            PacketCollector chat32 = getConnection(3).createPacketCollector(
+                    new ThreadFilter(chat31.getThreadID()));
+
+            for (int i=0; i<500; i++) {
+                chat11.sendMessage("Hello_1" + i);
+                chat21.sendMessage("Hello_2" + i);
+                chat31.sendMessage("Hello_3" + i);
+            }
+            for (int i=0; i<500; i++) {
+                assertNotNull("Some message was lost (" + i + ")", chat12.nextResult(1000));
+                assertNotNull("Some message was lost (" + i + ")", chat22.nextResult(1000));
+                assertNotNull("Some message was lost (" + i + ")", chat32.nextResult(1000));
+            }
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    /*public void testMUCFlood() {
+        try {
+            int floodNumber = 50000;
+            MultiUserChat chat = new MultiUserChat(getConnection(0), "myroom@" + getMUCDomain());
+            chat.create("phatom");
+            chat.sendConfigurationForm(new Form(Form.TYPE_SUBMIT));
+
+            MultiUserChat chat2 = new MultiUserChat(getConnection(1), "myroom@" + getMUCDomain());
+            chat2.join("christine");
+
+            for (int i=0; i<floodNumber; i++)
+            {
+                chat.sendMessage("hi");
+            }
+
+            Thread.sleep(200);
+
+            for (int i=0; i<floodNumber; i++)
+            {
+                if (i % 100 == 0) {
+                    System.out.println(i);
+                }
+                assertNotNull("Received " + i + " of " + floodNumber + " messages",
+                        chat2.nextMessage(SmackConfiguration.getPacketReplyTimeout()));
+            }
+
+            chat.leave();
+            //chat2.leave();
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }*/
+
+    protected int getMaxConnections() {
+        return 4;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/IQTest.java

@@ -0,0 +1,102 @@
+/**
+ *
+ * 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.smack;
+
+import org.jivesoftware.smack.filter.AndFilter;
+import org.jivesoftware.smack.filter.PacketFilter;
+import org.jivesoftware.smack.filter.PacketIDFilter;
+import org.jivesoftware.smack.filter.PacketTypeFilter;
+import org.jivesoftware.smack.packet.IQ;
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.jivesoftware.smackx.packet.Version;
+
+/**
+ * Ensure that the server is handling IQ packets correctly.
+ *
+ * @author Gaston Dombiak
+ */
+public class IQTest extends SmackTestCase {
+
+    public IQTest(String arg0) {
+        super(arg0);
+    }
+
+    /**
+     * Check that the server responds a 503 error code when the client sends an IQ packet with an
+     * invalid namespace.
+     */
+    public void testInvalidNamespace() {
+        IQ iq = new IQ() {
+            public String getChildElementXML() {
+                StringBuilder buf = new StringBuilder();
+                buf.append("<query xmlns=\"jabber:iq:anything\">");
+                buf.append("</query>");
+                return buf.toString();
+            }
+        };
+
+        PacketFilter filter = new AndFilter(new PacketIDFilter(iq.getPacketID()),
+                new PacketTypeFilter(IQ.class));
+        PacketCollector collector = getConnection(0).createPacketCollector(filter);
+        // Send the iq packet with an invalid namespace
+        getConnection(0).sendPacket(iq);
+
+        IQ result = (IQ)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
+        // Stop queuing results
+        collector.cancel();
+        if (result == null) {
+            fail("No response from server");
+        }
+        else if (result.getType() != IQ.Type.ERROR) {
+            fail("The server didn't reply with an error packet");
+        }
+        else {
+            assertEquals("Server answered an incorrect error code", 503, result.getError().getCode());
+        }
+    }
+
+    /**
+     * Check that sending an IQ to a full JID that is offline returns an IQ ERROR instead
+     * of being route to some other resource of the same user. 
+     */
+    public void testFullJIDToOfflineUser() {
+        // Request the version from the server.
+        Version versionRequest = new Version();
+        versionRequest.setType(IQ.Type.GET);
+        versionRequest.setFrom(getFullJID(0));
+        versionRequest.setTo(getBareJID(0) + "/Something");
+
+        // Create a packet collector to listen for a response.
+        PacketCollector collector = getConnection(0).createPacketCollector(
+                       new PacketIDFilter(versionRequest.getPacketID()));
+
+        getConnection(0).sendPacket(versionRequest);
+
+        // Wait up to 5 seconds for a result.
+        IQ result = (IQ)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
+        // Stop queuing results
+        collector.cancel();
+        assertNotNull("No response from server", result);
+        assertEquals("The server didn't reply with an error packet", IQ.Type.ERROR, result.getType());
+        assertEquals("Server answered an incorrect error code", 503, result.getError().getCode());
+    }
+
+    protected int getMaxConnections() {
+        return 1;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/LoginTest.java

@@ -0,0 +1,184 @@
+/**
+ *
+ * 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.smack;
+
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.jivesoftware.smack.util.StringUtils;
+
+/**
+ * Includes set of login tests. 
+ *
+ * @author Gaston Dombiak
+ */
+public class LoginTest extends SmackTestCase {
+
+    public LoginTest(String arg0) {
+        super(arg0);
+    }
+
+    /**
+     * Check that the server is returning the correct error when trying to login using an invalid
+     * (i.e. non-existent) user.
+     */
+    public void testInvalidLogin() {
+        try {
+            XMPPTCPConnection connection = createConnection();
+            connection.connect();
+            try {
+                // Login with an invalid user
+                connection.login("invaliduser" , "invalidpass");
+                connection.disconnect();
+                fail("Invalid user was able to log into the server");
+            }
+            catch (XMPPException e) {
+                if (e.getXMPPError() != null) {
+                    assertEquals("Incorrect error code while login with an invalid user", 401,
+                            e.getXMPPError().getCode());
+                }
+            }
+            // Wait here while trying tests with exodus
+            //Thread.sleep(300);
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * Check that the server handles anonymous users correctly.
+     */
+    public void testSASLAnonymousLogin() {
+        if (!isTestAnonymousLogin()) return;
+
+        try {
+            XMPPTCPConnection conn1 = createConnection();
+            XMPPTCPConnection conn2 = createConnection();
+            conn1.connect();
+            conn2.connect();
+            try {
+                // Try to login anonymously
+                conn1.loginAnonymously();
+                conn2.loginAnonymously();
+
+                assertNotNull("Resource is null", StringUtils.parseResource(conn1.getUser()));
+                assertNotNull("Resource is null", StringUtils.parseResource(conn2.getUser()));
+
+                assertNotNull("Username is null", StringUtils.parseName(conn1.getUser()));
+                assertNotNull("Username is null", StringUtils.parseName(conn2.getUser()));
+            }
+            catch (XMPPException e) {
+                fail(e.getMessage());
+            }
+            finally {
+                // Close the connection
+                conn1.disconnect();
+                conn2.disconnect();
+            }
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * Check that the server handles anonymous users correctly.
+     */
+    public void testNonSASLAnonymousLogin() {
+        if (!isTestAnonymousLogin()) return;
+
+        try {
+            ConnectionConfiguration config = new ConnectionConfiguration(getHost(), getPort());
+            config.setSASLAuthenticationEnabled(false);
+            XMPPTCPConnection conn1 = new XMPPConnection(config);
+            conn1.connect();
+
+            config = new ConnectionConfiguration(getHost(), getPort());
+            config.setSASLAuthenticationEnabled(false);
+            XMPPTCPConnection conn2 = new XMPPConnection(config);
+            conn2.connect();
+            
+            try {
+                // Try to login anonymously
+                conn1.loginAnonymously();
+                conn2.loginAnonymously();
+
+                assertNotNull("Resource is null", StringUtils.parseResource(conn1.getUser()));
+                assertNotNull("Resource is null", StringUtils.parseResource(conn2.getUser()));
+
+                assertNotNull("Username is null", StringUtils.parseName(conn1.getUser()));
+                assertNotNull("Username is null", StringUtils.parseName(conn2.getUser()));
+            }
+            catch (XMPPException e) {
+                fail(e.getMessage());
+            }
+            // Close the connection
+            conn1.disconnect();
+            conn2.disconnect();
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * Check that the server does not allow to log in without specifying a resource.
+     */
+    public void testLoginWithNoResource() {
+        try {
+            XMPPTCPConnection conn = createConnection();
+            conn.connect();
+            try {
+                conn.getAccountManager().createAccount("user_1", "user_1", getAccountCreationParameters());
+            } catch (XMPPException e) {
+                // Do nothing if the account already exists
+                if (e.getXMPPError().getCode() != 409) {
+                    throw e;
+                }
+                // Else recreate the connection, ins case the server closed it as
+                // a result of the error, so we can login.
+                conn = createConnection();
+                conn.connect();
+            }
+            conn.login("user_1", "user_1", (String) null);
+            if (conn.getSASLAuthentication().isAuthenticated()) {
+                // Check that the server assigned a resource
+                assertNotNull("JID assigned by server is missing", conn.getUser());
+                assertNotNull("JID assigned by server does not have a resource",
+                        StringUtils.parseResource(conn.getUser()));
+                conn.disconnect();
+            }
+            else {
+                fail("User with no resource was not able to log into the server");
+            }
+
+        } catch (XMPPException e) {
+            if (e.getXMPPError() != null) {
+                assertEquals("Wrong error code returned", 406, e.getXMPPError().getCode());
+            } else {
+                fail(e.getMessage());
+            }
+        }
+    }
+
+    protected int getMaxConnections() {
+        return 0;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/MessageTest.java

@@ -0,0 +1,408 @@
+/**
+ *
+ * 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.smack;
+
+import org.jivesoftware.smack.filter.MessageTypeFilter;
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smack.test.SmackTestCase;
+
+/**
+ * Tests sending messages to other clients.
+ *
+ * @author Gaston Dombiak
+ */
+public class MessageTest extends SmackTestCase {
+
+    public MessageTest(String arg0) {
+        super(arg0);
+    }
+
+    /**
+     * Will a user recieve a message from another after only sending the user a directed presence,
+     * or will Wildfire intercept for offline storage?
+     *
+     * User1 becomes lines. User0 never sent an available presence to the server but
+     * instead sent one to User1. User1 sends a message to User0. Should User0 get the
+     * message?
+     */
+    public void testDirectPresence() {
+        getConnection(1).sendPacket(new Presence(Presence.Type.available));
+
+        Presence presence = new Presence(Presence.Type.available);
+        presence.setTo(getBareJID(1));
+        getConnection(0).sendPacket(presence);
+
+        PacketCollector collector = getConnection(0)
+                .createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+        try {
+            getConnection(1).getChatManager().createChat(getBareJID(0), null).sendMessage("Test 1");
+        }
+        catch (XMPPException e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+
+        Message message = (Message) collector.nextResult(2500);
+        assertNotNull("Message not recieved from remote user", message);
+    }
+
+    /**
+     * Check that when a client becomes unavailable all messages sent to the client are stored offline. So that when
+     * the client becomes available again the offline messages are received.
+     */
+    public void testOfflineMessage() {
+        getConnection(0).sendPacket(new Presence(Presence.Type.available));
+        getConnection(1).sendPacket(new Presence(Presence.Type.available));
+        // Make user2 unavailable
+        getConnection(1).sendPacket(new Presence(Presence.Type.unavailable));
+
+        try {
+            Thread.sleep(500);
+
+            // User1 sends some messages to User2 which is not available at the moment
+            Chat chat = getConnection(0).getChatManager().createChat(getBareJID(1), null);
+            PacketCollector collector = getConnection(1).createPacketCollector(
+                    new MessageTypeFilter(Message.Type.chat));
+            chat.sendMessage("Test 1");
+            chat.sendMessage("Test 2");
+
+            Thread.sleep(500);
+
+            // User2 becomes available again
+
+            getConnection(1).sendPacket(new Presence(Presence.Type.available));
+
+            // Check that offline messages are retrieved by user2 which is now available
+            Message message = (Message) collector.nextResult(2500);
+            assertNotNull(message);
+            message = (Message) collector.nextResult(2000);
+            assertNotNull(message);
+            message = (Message) collector.nextResult(1000);
+            assertNull(message);
+
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * Send messages with invalid XML characters to offline users. Check that offline users
+     * are receiving them from the server.<p>
+     *
+     * Test case commented out since some servers may just close the connection while others
+     * are more tolerant and accept stanzas with invalid XML characters.
+     */
+    /*public void testOfflineMessageInvalidXML() {
+        // Make user2 unavailable
+        getConnection(1).sendPacket(new Presence(Presence.Type.unavailable));
+
+        try {
+            Thread.sleep(500);
+
+            // User1 sends some messages to User2 which is not available at the moment
+            Chat chat = getConnection(0).getChatManager().createChat(getBareJID(1), null);
+            PacketCollector collector = getConnection(1).createPacketCollector(
+                    new MessageTypeFilter(Message.Type.chat));
+            chat.sendMessage("Test \f 1");
+            chat.sendMessage("Test \r 1");
+
+            Thread.sleep(500);
+
+            // User2 becomes available again
+
+            getConnection(1).sendPacket(new Presence(Presence.Type.available));
+
+            // Check that offline messages are retrieved by user2 which is now available
+            Message message = (Message) collector.nextResult(2500);
+            assertNotNull(message);
+            message = (Message) collector.nextResult(2000);
+            assertNotNull(message);
+            message = (Message) collector.nextResult(1000);
+            assertNull(message);
+
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }*/
+
+    /**
+     * Check that two clients are able to send messages with a body of 4K characters and their
+     * connections are not being closed.
+     */
+    public void testHugeMessage() {
+        getConnection(0).sendPacket(new Presence(Presence.Type.available));
+        getConnection(1).sendPacket(new Presence(Presence.Type.available));
+        // User2 becomes available again
+        PacketCollector collector = getConnection(1).createPacketCollector(
+                new MessageTypeFilter(Message.Type.chat));
+
+        // Create message with a body of 4K characters
+        Message msg = new Message(getFullJID(1), Message.Type.chat);
+        StringBuilder sb = new StringBuilder(5000);
+        for (int i = 0; i <= 4000; i++) {
+            sb.append("X");
+        }
+        msg.setBody(sb.toString());
+
+        // Send the first message
+        getConnection(0).sendPacket(msg);
+        // Check that the connection that sent the message is still connected
+        assertTrue("XMPPConnection was closed", getConnection(0).isConnected());
+        // Check that the message was received
+        Message rcv = (Message) collector.nextResult(1000);
+        assertNotNull("No Message was received", rcv);
+
+        // Send the second message
+        getConnection(0).sendPacket(msg);
+        // Check that the connection that sent the message is still connected
+        assertTrue("XMPPConnection was closed", getConnection(0).isConnected());
+        // Check that the second message was received
+        rcv = (Message) collector.nextResult(1000);
+        assertNotNull("No Message was received", rcv);
+    }
+
+
+    /**
+     * User0 is connected from 2 resources. User0 is available in both resources
+     * but with different priority presence values. User1 sends a message to the
+     * bare JID of User0. Check that the resource with highest priority will get
+     * the messages.
+     *
+     * @throws Exception if an error occurs.
+     */
+    public void testHighestPriority() throws Exception {
+        // Create another connection for the same user of connection 1
+        ConnectionConfiguration connectionConfiguration =
+                new ConnectionConfiguration(getHost(), getPort(), getServiceName());
+        XMPPTCPConnection conn3 = new XMPPConnection(connectionConfiguration);
+        conn3.connect();
+        conn3.login(getUsername(0), getPassword(0), "Home");
+        // Set this connection as highest priority
+        Presence presence = new Presence(Presence.Type.available);
+        presence.setPriority(10);
+        conn3.sendPacket(presence);
+        // Set this connection as highest priority
+        presence = new Presence(Presence.Type.available);
+        presence.setPriority(5);
+        getConnection(0).sendPacket(presence);
+
+        // Let the server process the change in presences
+        Thread.sleep(200);
+
+        // User0 listen in both connected clients
+        PacketCollector collector = getConnection(0).createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+        PacketCollector coll3 = conn3.createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+
+        // User1 sends a message to the bare JID of User0 
+        Chat chat = getConnection(1).getChatManager().createChat(getBareJID(0), null);
+        chat.sendMessage("Test 1");
+        chat.sendMessage("Test 2");
+
+        // Check that messages were sent to resource with highest priority
+        Message message = (Message) collector.nextResult(2000);
+        assertNull("Resource with lowest priority got the message", message);
+        message = (Message) coll3.nextResult(2000);
+        assertNotNull(message);
+        assertEquals("Test 1", message.getBody());
+        message = (Message) coll3.nextResult(1000);
+        assertNotNull(message);
+        assertEquals("Test 2", message.getBody());
+
+        conn3.disconnect();
+    }
+
+    /**
+     * User0 is connected from 2 resources. User0 is available in both resources
+     * but with different show values. User1 sends a message to the
+     * bare JID of User0. Check that the resource with highest show value will get
+     * the messages.
+     *
+     * @throws Exception if an error occurs.
+     */
+    public void testHighestShow() throws Exception {
+        // Create another connection for the same user of connection 1
+        ConnectionConfiguration connectionConfiguration =
+                new ConnectionConfiguration(getHost(), getPort(), getServiceName());
+        XMPPTCPConnection conn3 = new XMPPConnection(connectionConfiguration);
+        conn3.connect();
+        conn3.login(getUsername(0), getPassword(0), "Home");
+        // Set this connection as highest priority
+        Presence presence = new Presence(Presence.Type.available);
+        presence.setMode(Presence.Mode.away);
+        conn3.sendPacket(presence);
+        // Set this connection as highest priority
+        presence = new Presence(Presence.Type.available);
+        presence.setMode(Presence.Mode.available);
+        getConnection(0).sendPacket(presence);
+
+        // Let the server process the change in presences
+        Thread.sleep(200);
+
+        // User0 listen in both connected clients
+        PacketCollector collector = getConnection(0).createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+        PacketCollector coll3 = conn3.createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+
+        // User1 sends a message to the bare JID of User0
+        Chat chat = getConnection(1).getChatManager().createChat(getBareJID(0), null);
+        chat.sendMessage("Test 1");
+        chat.sendMessage("Test 2");
+
+        // Check that messages were sent to resource with highest priority
+        Message message = (Message) coll3.nextResult(2000);
+        assertNull("Resource with lowest show value got the message", message);
+        message = (Message) collector.nextResult(2000);
+        assertNotNull(message);
+        assertEquals("Test 1", message.getBody());
+        message = (Message) collector.nextResult(1000);
+        assertNotNull(message);
+        assertEquals("Test 2", message.getBody());
+
+        conn3.disconnect();
+    }
+
+    /**
+     * User0 is connected from 2 resources. User0 is available in both resources
+     * with same priority presence values and same show values. User1 sends a message to the
+     * bare JID of User0. Check that the resource with most recent activity will get
+     * the messages.
+     *
+     * @throws Exception if an error occurs.
+     */
+    public void testMostRecentActive() throws Exception {
+        // Create another connection for the same user of connection 1
+        ConnectionConfiguration connectionConfiguration =
+                new ConnectionConfiguration(getHost(), getPort(), getServiceName());
+        XMPPTCPConnection conn3 = new XMPPConnection(connectionConfiguration);
+        conn3.connect();
+        conn3.login(getUsername(0), getPassword(0), "Home");
+        // Set this connection as highest priority
+        Presence presence = new Presence(Presence.Type.available);
+        presence.setMode(Presence.Mode.available);
+        presence.setPriority(10);
+        conn3.sendPacket(presence);
+        // Set this connection as highest priority
+        presence = new Presence(Presence.Type.available);
+        presence.setMode(Presence.Mode.available);
+        presence.setPriority(10);
+        getConnection(0).sendPacket(presence);
+
+        connectionConfiguration =
+                new ConnectionConfiguration(getHost(), getPort(), getServiceName());
+        XMPPTCPConnection conn4 = new XMPPConnection(connectionConfiguration);
+        conn4.connect();
+        conn4.login(getUsername(0), getPassword(0), "Home2");
+        presence = new Presence(Presence.Type.available);
+        presence.setMode(Presence.Mode.available);
+        presence.setPriority(4);
+        getConnection(0).sendPacket(presence);
+
+
+        // Let the server process the change in presences
+        Thread.sleep(200);
+
+        // User0 listen in both connected clients
+        PacketCollector collector = getConnection(0).createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+        PacketCollector coll3 = conn3.createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+        PacketCollector coll4 = conn4.createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+
+        // Send a message from this resource to indicate most recent activity 
+        conn3.sendPacket(new Message("admin@" + getServiceName()));
+
+        // User1 sends a message to the bare JID of User0
+        Chat chat = getConnection(1).getChatManager().createChat(getBareJID(0), null);
+        chat.sendMessage("Test 1");
+        chat.sendMessage("Test 2");
+
+        // Check that messages were sent to resource with highest priority
+        Message message = (Message) collector.nextResult(2000);
+        assertNull("Resource with oldest activity got the message", message);
+        message = (Message) coll4.nextResult(2000);
+        assertNull(message);
+        message = (Message) coll3.nextResult(2000);
+        assertNotNull(message);
+        assertEquals("Test 1", message.getBody());
+        message = (Message) coll3.nextResult(1000);
+        assertNotNull(message);
+        assertEquals("Test 2", message.getBody());
+
+        conn3.disconnect();
+        conn4.disconnect();
+    }
+
+    /**
+     * User0 is connected from 1 resource with a negative priority presence. User1
+     * sends a message to the bare JID of User0. Messages should be stored offline.
+     * User0 then changes the priority presence to a positive value. Check that
+     * offline messages were delivered to the user.
+     *
+     * @throws Exception if an error occurs.
+     */
+    public void testOfflineStorageWithNegativePriority() throws Exception {
+        // Set this connection with negative priority
+        Presence presence = new Presence(Presence.Type.available);
+        presence.setMode(Presence.Mode.available);
+        presence.setPriority(-1);
+        getConnection(0).sendPacket(presence);
+
+        // Let the server process the change in presences
+        Thread.sleep(200);
+
+        // User0 listen for incoming traffic
+        PacketCollector collector = getConnection(0).createPacketCollector(new MessageTypeFilter(Message.Type.chat));
+
+        // User1 sends a message to the bare JID of User0
+        Chat chat = getConnection(1).getChatManager().createChat(getBareJID(0), null);
+        chat.sendMessage("Test 1");
+        chat.sendMessage("Test 2");
+
+        // Check that messages were sent to resource with highest priority
+        Message message = (Message) collector.nextResult(2000);
+        assertNull("Messages were not stored offline", message);
+
+        // Set this connection with positive priority
+        presence = new Presence(Presence.Type.available);
+        presence.setMode(Presence.Mode.available);
+        presence.setPriority(1);
+        getConnection(0).sendPacket(presence);
+
+        // Let the server process the change in presences
+        Thread.sleep(200);
+
+        message = (Message) collector.nextResult(2000);
+        assertNotNull("Offline messages were not delivered", message);
+        assertEquals("Test 1", message.getBody());
+        message = (Message) collector.nextResult(1000);
+        assertNotNull(message);
+        assertEquals("Test 2", message.getBody());
+    }
+
+    protected int getMaxConnections() {
+        return 2;
+    }
+
+
+    @Override
+    protected boolean sendInitialPresence() {
+        return false;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/PacketReaderTest.java

@@ -0,0 +1,257 @@
+/**
+ *
+ * Copyright 2004 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.smack;
+
+import org.jivesoftware.smack.filter.FromMatchesFilter;
+import org.jivesoftware.smack.filter.PacketIDFilter;
+import org.jivesoftware.smack.filter.PacketTypeFilter;
+import org.jivesoftware.smack.filter.PacketFilter;
+import org.jivesoftware.smack.packet.*;
+import org.jivesoftware.smack.test.SmackTestCase;
+
+import java.util.Date;
+
+
+public class PacketReaderTest extends SmackTestCase {
+
+    private int counter;
+
+    private final Object mutex = new Object();
+
+    /**
+     * Constructor for PacketReaderTest.
+     *
+     * @param arg0
+     */
+    public PacketReaderTest(String arg0) {
+        super(arg0);
+        resetCounter();
+    }
+
+    // Counter management
+
+    private void resetCounter() {
+        synchronized (mutex) {
+            counter = 0;
+        }
+    }
+
+    public void incCounter() {
+        synchronized (mutex) {
+            counter++;
+        }
+    }
+
+    private int valCounter() {
+        int val;
+        synchronized (mutex) {
+            val = counter;
+        }
+        return val;
+    }
+
+    /**
+     * Verify that when Smack receives a "not implemented IQ" answers with an IQ packet
+     * with error code 501.
+     */
+    public void testIQNotImplemented() {
+
+        // Create a new type of IQ to send. The new IQ will include a
+        // non-existant namespace to cause the "feature-not-implemented" answer
+        IQ iqPacket = new IQ() {
+            public String getChildElementXML() {
+                return "<query xmlns=\"my:ns:test\"/>";
+            }
+        };
+        iqPacket.setTo(getFullJID(1));
+        iqPacket.setType(IQ.Type.GET);
+
+        // Send the IQ and wait for the answer
+        PacketCollector collector = getConnection(0).createPacketCollector(
+                new PacketIDFilter(iqPacket.getPacketID()));
+        getConnection(0).sendPacket(iqPacket);
+        IQ response = (IQ) collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
+        if (response == null) {
+            fail("No response from the other user.");
+        }
+        assertEquals("The received IQ is not of type ERROR", IQ.Type.ERROR, response.getType());
+        assertEquals("The error code is not 501", 501, response.getError().getCode());
+        collector.cancel();
+    }
+
+    /**
+     * Tests that PacketReader adds new listeners and also removes them correctly.
+     */
+    public void testRemoveListener() {
+
+        PacketListener listener = new PacketListener() {
+            public void processPacket(Packet packet) {
+                // Do nothing
+            }
+        };
+        // Keep number of current listeners
+        int listenersSize = getConnection(0).getPacketListeners().size();
+        // Add a new listener
+        getConnection(0).addPacketListener(listener, new MockPacketFilter(true));
+        // Check that the listener was added
+        assertEquals("Listener was not added", listenersSize + 1,
+                getConnection(0).getPacketListeners().size());
+
+        Message msg = new Message(getConnection(0).getUser(), Message.Type.normal);
+
+        getConnection(1).sendPacket(msg);
+
+        // Remove the listener
+        getConnection(0).removePacketListener(listener);
+        // Check that the number of listeners is correct (i.e. the listener was removed)
+        assertEquals("Listener was not removed", listenersSize,
+                getConnection(0).getPacketListeners().size());
+    }
+
+    /**
+     * Checks that parser still works when receiving an error text with no description.
+     */
+    public void testErrorWithNoText() {
+        // Send a regular message from user0 to user1
+        Message packet = new Message();
+        packet.setFrom(getFullJID(0));
+        packet.setTo(getFullJID(1));
+        packet.setBody("aloha");
+
+        // User1 will always reply to user0 when a message is received
+        getConnection(1).addPacketListener(new PacketListener() {
+            public void processPacket(Packet packet) {
+                System.out.println(new Date() + " " + packet);
+
+                Message message = new Message(packet.getFrom());
+                message.setFrom(getFullJID(1));
+                message.setBody("HELLO");
+                getConnection(1).sendPacket(message);
+            }
+        }, new PacketTypeFilter(Message.class));
+
+        // User0 listen for replies from user1
+        PacketCollector collector = getConnection(0).createPacketCollector(
+                new FromMatchesFilter(getFullJID(1)));
+        // User0 sends the regular message to user1
+        getConnection(0).sendPacket(packet);
+        // Check that user0 got a reply from user1
+        assertNotNull("No message was received", collector.nextResult(1000));
+
+        // Send a message with an empty error text
+        packet = new Message();
+        packet.setFrom(getFullJID(0));
+        packet.setTo(getFullJID(1));
+        packet.setBody("aloha");
+        packet.setError(new XMPPError(XMPPError.Condition.feature_not_implemented, null));
+        getConnection(0).sendPacket(packet);
+        // Check that user0 got a reply from user1
+        assertNotNull("No message was received", collector.nextResult(1000));
+    }
+
+    /**
+     * Tests that PacketReader adds new listeners and also removes them correctly.
+     */
+    public void testFiltersRemotion() {
+
+        resetCounter();
+
+        int repeat = 10;
+
+        for (int j = 0; j < repeat; j++) {
+
+            PacketListener listener0 = new PacketListener() {
+                public void processPacket(Packet packet) {
+                    System.out.println("Packet Captured");
+                    incCounter();
+                }
+            };
+            PacketFilter pf0 = new PacketFilter() {
+                public boolean accept(Packet packet) {
+                    System.out.println("Packet Filtered");
+                    incCounter();
+                    return true;
+                }
+            };
+
+            PacketListener listener1 = new PacketListener() {
+                public void processPacket(Packet packet) {
+                    System.out.println("Packet Captured");
+                    incCounter();
+                }
+            };
+            PacketFilter pf1 = new PacketFilter() {
+                public boolean accept(Packet packet) {
+                    System.out.println("Packet Filtered");
+                    incCounter();
+                    return true;
+                }
+            };
+
+            getConnection(0).addPacketListener(listener0, pf0);
+            getConnection(1).addPacketListener(listener1, pf1);
+
+            // Check that the listener was added
+
+            Message msg0 = new Message(getConnection(0).getUser(), Message.Type.normal);
+            Message msg1 = new Message(getConnection(1).getUser(), Message.Type.normal);
+
+
+            for (int i = 0; i < 5; i++) {
+                getConnection(1).sendPacket(msg0);
+                getConnection(0).sendPacket(msg1);
+            }
+
+            try {
+                Thread.sleep(100);
+            }
+            catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+
+            // Remove the listener
+            getConnection(0).removePacketListener(listener0);
+            getConnection(1).removePacketListener(listener1);
+
+            try {
+                Thread.sleep(300);
+            }
+            catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+
+            for (int i = 0; i < 10; i++) {
+                getConnection(0).sendPacket(msg1);
+                getConnection(1).sendPacket(msg0);
+            }
+
+            try {
+                Thread.sleep(100);
+            }
+            catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        System.out.println(valCounter());
+        assertEquals(valCounter(), repeat * 2 * 10);
+    }
+
+    protected int getMaxConnections() {
+        return 2;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/PresenceTest.java

@@ -0,0 +1,274 @@
+/**
+ *
+ * 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.smack;
+
+import java.util.Iterator;
+
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smack.test.SmackTestCase;
+
+/**
+ * Ensure that the server is delivering messages to the correct client based on the client's
+ * presence priority.
+ *
+ * @author Gaston Dombiak
+ */
+public class PresenceTest extends SmackTestCase {
+
+    public PresenceTest(String arg0) {
+        super(arg0);
+    }
+
+    /**
+     * XMPPConnection(0) will send messages to the bareJID of XMPPConnection(1) where the user of
+     * XMPPConnection(1) has logged from two different places with different presence priorities.
+     */
+    public void testMessageToHighestPriority() {
+        XMPPTCPConnection conn = null;
+        try {
+            // User_1 will log in again using another resource
+            conn = createConnection();
+            conn.connect();
+            conn.login(getUsername(1), getUsername(1), "OtherPlace");
+            // Change the presence priorities of User_1
+            getConnection(1).sendPacket(new Presence(Presence.Type.available, null, 1,
+                    Presence.Mode.available));
+            conn.sendPacket(new Presence(Presence.Type.available, null, 2,
+                    Presence.Mode.available));
+            Thread.sleep(150);
+            // Create the chats between the participants
+            Chat chat0 = getConnection(0).getChatManager().createChat(getBareJID(1), null);
+            Chat chat1 = getConnection(1).getChatManager().createChat(getBareJID(0), chat0.getThreadID(), null);
+            Chat chat2 = conn.getChatManager().createChat(getBareJID(0), chat0.getThreadID(), null);
+
+            // Test delivery of message to the presence with highest priority
+            chat0.sendMessage("Hello");
+            /*assertNotNull("Resource with highest priority didn't receive the message",
+                    chat2.nextMessage(2000));
+            assertNull("Resource with lowest priority received the message",
+                    chat1.nextMessage(1000));*/
+
+            // Invert the presence priorities of User_1
+            getConnection(1).sendPacket(new Presence(Presence.Type.available, null, 2,
+                    Presence.Mode.available));
+            conn.sendPacket(new Presence(Presence.Type.available, null, 1,
+                    Presence.Mode.available));
+
+            Thread.sleep(150);
+            // Test delivery of message to the presence with highest priority
+            chat0.sendMessage("Hello");
+            /*assertNotNull("Resource with highest priority didn't receive the message",
+                    chat1.nextMessage(2000));
+            assertNull("Resource with lowest priority received the message",
+                    chat2.nextMessage(1000));*/
+
+            // User_1 closes his connection
+            conn.disconnect();
+            Thread.sleep(150);
+
+            // Test delivery of message to the unique presence of the user_1
+            chat0.sendMessage("Hello");
+            /*assertNotNull("Resource with highest priority didn't receive the message",
+                    chat1.nextMessage(2000));*/
+
+            getConnection(1).sendPacket(new Presence(Presence.Type.available, null, 2,
+                    Presence.Mode.available));
+
+            // User_1 will log in again using another resource
+            conn = createConnection();
+            conn.connect();
+            conn.login(getUsername(1), getPassword(1), "OtherPlace");
+            conn.sendPacket(new Presence(Presence.Type.available, null, 1,
+                    Presence.Mode.available));
+            chat2 = conn.getChatManager().createChat(getBareJID(0), chat0.getThreadID(), null);
+
+            Thread.sleep(150);
+            // Test delivery of message to the presence with highest priority
+            chat0.sendMessage("Hello");
+            /*assertNotNull("Resource with highest priority didn't receive the message",
+                    chat1.nextMessage(2000));
+            assertNull("Resource with lowest priority received the message",
+                    chat2.nextMessage(1000));*/
+
+            // Invert the presence priorities of User_1
+            getConnection(1).sendPacket(new Presence(Presence.Type.available, null, 1,
+                    Presence.Mode.available));
+            conn.sendPacket(new Presence(Presence.Type.available, null, 2,
+                    Presence.Mode.available));
+
+            Thread.sleep(150);
+            // Test delivery of message to the presence with highest priority
+            chat0.sendMessage("Hello");
+            /*assertNotNull("Resource with highest priority didn't receive the message",
+                    chat2.nextMessage(2000));
+            assertNull("Resource with lowest priority received the message",
+                    chat1.nextMessage(1000));*/
+
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+        finally {
+            if (conn != null) {
+                conn.disconnect();
+            }
+        }
+    }
+
+    /**
+     * User1 logs from 2 resources but only one is available. User0 sends a message
+     * to the full JID of the unavailable resource. User1 in the not available resource
+     * should receive the message.
+     * TODO Fix this in Wildfire but before check if XMPP spec requests this feature
+     */
+    public void testNotAvailablePresence() throws XMPPException {
+        // Change the presence to unavailable of User_1
+        getConnection(1).sendPacket(new Presence(Presence.Type.unavailable));
+
+        // User_1 will log in again using another resource (that is going to be available)
+        XMPPTCPConnection conn = createConnection();
+        conn.connect();
+        conn.login(getUsername(1), getPassword(1), "OtherPlace");
+
+        // Create chats between participants
+        Chat chat0 = getConnection(0).getChatManager().createChat(getFullJID(1), null);
+        Chat chat1 = getConnection(1).getChatManager().createChat(getBareJID(0), chat0.getThreadID(), null);
+
+        // Test delivery of message to the presence with highest priority
+        chat0.sendMessage("Hello");
+        /*assertNotNull("Not available connection didn't receive message sent to full JID",
+                chat1.nextMessage(2000));
+        assertNull("Not available connection received an unknown message",
+                chat1.nextMessage(1000));*/
+        conn.disconnect();
+
+    }
+
+    /**
+     * User1 is connected from 2 resources. User1 adds User0 to his roster. Ensure
+     * that presences are correctly retrieved for User1. User1 logs off from one resource
+     * and ensure that presences are still correct for User1.
+     */
+    public void testMultipleResources() throws Exception {
+        // Create another connection for the same user of connection 1
+        ConnectionConfiguration connectionConfiguration =
+                new ConnectionConfiguration(getHost(), getPort(), getServiceName());
+        XMPPTCPConnection conn4 = new XMPPConnection(connectionConfiguration);
+        conn4.connect();
+        conn4.login(getUsername(1), getPassword(1), "Home");
+
+        // Add a new roster entry
+        Roster roster = getConnection(0).getRoster();
+        roster.createEntry(getBareJID(1), "gato1", null);
+
+        // Wait up to 2 seconds
+        long initial = System.currentTimeMillis();
+        while (System.currentTimeMillis() - initial < 2000 && (
+                !roster.getPresence(getBareJID(1)).isAvailable()))
+        {
+            Thread.sleep(100);
+        }
+
+        // Check that a presence is returned for the new contact
+        Presence presence = roster.getPresence(getBareJID(1));
+        assertTrue("Returned an offline Presence for an existing user", presence.isAvailable());
+
+        presence = roster.getPresenceResource(getBareJID(1) + "/Home");
+        assertTrue("Returned an offline Presence for Home resource", presence.isAvailable());
+
+        presence = roster.getPresenceResource(getFullJID(1));
+        assertTrue("Returned an offline Presence for Smack resource", presence.isAvailable());
+
+        Iterator<Presence> presences = roster.getPresences(getBareJID(1));
+        assertTrue("Returned an offline Presence for an existing user", presence.isAvailable());
+        assertNotNull("No presence was found for user1", presences);
+        assertTrue("No presence was found for user1", presences.hasNext());
+        presences.next();
+        assertTrue("Only one presence was found for user1", presences.hasNext());
+
+        // User1 logs out from one resource
+        conn4.disconnect();
+
+        // Wait up to 1 second
+        Thread.sleep(700);
+
+        // Check that a presence is returned for the new contact
+        presence = roster.getPresence(getBareJID(1));
+        assertTrue("Returned a null Presence for an existing user", presence.isAvailable());
+
+        presence = roster.getPresenceResource(getFullJID(1));
+        assertTrue("Returned a null Presence for Smack resource", presence.isAvailable());
+
+        presence = roster.getPresenceResource(getBareJID(1) + "/Home");
+        assertTrue("Returned a Presence for no longer connected resource", !presence.isAvailable());
+
+        presences = roster.getPresences(getBareJID(1));
+        assertNotNull("No presence was found for user1", presences);
+        Presence value = presences.next();
+        assertTrue("No presence was found for user1", value.isAvailable());
+        assertFalse("More than one presence was found for user1", presences.hasNext());
+    }
+
+    /**
+     * User1 logs in, then sets offline presence information (presence with status text). User2
+     * logs in and checks to see if offline presence is returned.
+     *
+     * @throws Exception if an exception occurs.
+     */
+    public void testOfflineStatusPresence() throws Exception {
+        // Add a new roster entry for other user.
+        Roster roster = getConnection(0).getRoster();
+        roster.createEntry(getBareJID(1), "gato1", null);
+
+        // Wait up to 2 seconds
+        long initial = System.currentTimeMillis();
+        while (System.currentTimeMillis() - initial < 2000 && (
+                roster.getPresence(getBareJID(1)).getType().equals(Presence.Type.unavailable))) {
+            Thread.sleep(100);
+        }
+
+        // Sign out of conn1 with status
+        Presence offlinePresence = new Presence(Presence.Type.unavailable);
+        offlinePresence.setStatus("Offline test");
+        getConnection(1).disconnect(offlinePresence);
+
+        // Wait 500 ms
+        Thread.sleep(500);
+        Presence presence = getConnection(0).getRoster().getPresence(getBareJID(1));
+        assertEquals("Offline presence status not received.", "Offline test", presence.getStatus());
+
+        // Sign out of conn0.
+        getConnection(0).disconnect();
+
+        // See if conneciton 0 can get offline status.
+        XMPPTCPConnection con0 = getConnection(0);
+        con0.connect();
+        con0.login(getUsername(0), getUsername(0));
+
+        // Wait 500 ms
+        Thread.sleep(500);
+        presence = con0.getRoster().getPresence(getBareJID(1));
+        assertTrue("Offline presence status not received after logout.",
+                "Offline test".equals(presence.getStatus()));
+    }
+
+    protected int getMaxConnections() {
+        return 2;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/PrivacyClient.java

@@ -0,0 +1,56 @@
+/**
+ *
+ * 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.smack;
+
+import java.util.List;
+
+import org.jivesoftware.smack.packet.Privacy;
+import org.jivesoftware.smack.packet.PrivacyItem;
+
+/**
+ * This class supports automated tests about privacy communication from the
+ * server to the client.
+ * 
+ * @author Francisco Vives
+ */
+
+public class PrivacyClient implements PrivacyListListener {
+    /**
+     * holds if the receiver list was modified
+     */
+    private boolean wasModified = false;
+
+    /**
+     * holds a privacy to hold server requests Clients should not use Privacy
+     * class since it is private for the smack framework.
+     */
+    private Privacy privacy = new Privacy();
+
+    public PrivacyClient(PrivacyListManager manager) {
+        super();
+    }
+
+    public void setPrivacyList(String listName, List<PrivacyItem> listItem) {
+        privacy.setPrivacyList(listName, listItem);
+    }
+
+    public void updatedPrivacyList(String listName) {
+        this.wasModified = true;
+    }
+
+    public boolean wasModified() {
+        return this.wasModified;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/ReconnectionTest.java

@@ -0,0 +1,257 @@
+/**
+ *
+ * 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.smack;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.jivesoftware.smackx.ping.PingManager;
+
+/**
+ * Tests the connection and reconnection mechanism
+ *
+ * @author Francisco Vives
+ */
+
+public class ReconnectionTest extends SmackTestCase {
+
+    private static final long MIN_RECONNECT_WAIT = 17;  // Seconds
+    
+    public ReconnectionTest(String arg0) {
+        super(arg0);
+    }
+
+    /**
+     * Tests an automatic reconnection.
+     * Simulates a connection error and then waits until gets reconnected.
+     */
+
+    public void testAutomaticReconnection() throws Exception {
+        XMPPTCPConnection connection = getConnection(0);
+        CountDownLatch latch = new CountDownLatch(1);
+        XMPPTCPConnectionTestListener listener = new XMPPConnectionTestListener(latch);
+        connection.addConnectionListener(listener);
+
+        // Simulates an error in the connection
+        connection.notifyConnectionError(new Exception("Simulated Error"));
+        latch.await(MIN_RECONNECT_WAIT, TimeUnit.SECONDS);
+        
+        // After 10 seconds, the reconnection manager must reestablishes the connection
+        assertEquals("The ConnectionListener.connectionStablished() notification was not fired", true, listener.reconnected);
+        assertTrue("The ReconnectionManager algorithm has reconnected without waiting at least 5 seconds", listener.attemptsNotifications > 0);
+
+        // Executes some server interaction testing the connection
+        executeSomeServerInteraction(connection);
+    }
+
+    public void testAutomaticReconnectionWithCompression() throws Exception {
+        // Create the configuration for this new connection
+        ConnectionConfiguration config = new ConnectionConfiguration(getHost(), getPort());
+        config.setCompressionEnabled(true);
+        config.setSASLAuthenticationEnabled(true);
+
+        XMPPTCPConnection connection = new XMPPConnection(config);
+        // Connect to the server
+        connection.connect();
+        // Log into the server
+        connection.login(getUsername(0), getPassword(0), "MyOtherResource");
+
+        assertTrue("Failed to use compression", connection.isUsingCompression());
+
+        // Executes some server interaction testing the connection
+        executeSomeServerInteraction(connection);
+
+        CountDownLatch latch = new CountDownLatch(1);
+        XMPPTCPConnectionTestListener listener = new XMPPConnectionTestListener(latch);
+        connection.addConnectionListener(listener);
+
+        // Simulates an error in the connection
+        connection.notifyConnectionError(new Exception("Simulated Error"));
+        latch.await(MIN_RECONNECT_WAIT, TimeUnit.SECONDS);
+        
+        // After 10 seconds, the reconnection manager must reestablishes the connection
+        assertEquals("The ConnectionListener.connectionEstablished() notification was not fired", true, listener.reconnected);
+        assertTrue("The ReconnectionManager algorithm has reconnected without waiting at least 5 seconds", listener.attemptsNotifications > 0);
+
+        // Executes some server interaction testing the connection
+        executeSomeServerInteraction(connection);
+    }
+
+    /**
+     * Tests a manual reconnection.
+     * Simulates a connection error, disables the reconnection mechanism and then reconnects.
+     */
+    public void testManualReconnectionWithCancelation() throws Exception {
+        XMPPTCPConnection connection = getConnection(0);
+        CountDownLatch latch = new CountDownLatch(1);
+        XMPPTCPConnectionTestListener listener = new XMPPConnectionTestListener(latch);
+        connection.addConnectionListener(listener);
+
+        // Produces a connection error
+        connection.notifyConnectionError(new Exception("Simulated Error"));
+        assertEquals(
+                "An error occurs but the ConnectionListener.connectionClosedOnError(e) was not notified",
+                true, listener.connectionClosedOnError);
+//        Thread.sleep(1000);
+        
+        // Cancels the automatic reconnection
+        connection.getConfiguration().setReconnectionAllowed(false);
+        // Waits for a reconnection that must not happened.
+        Thread.sleep(MIN_RECONNECT_WAIT * 1000);
+        // Cancels the automatic reconnection
+        assertEquals(false, listener.reconnected);
+
+        // Makes a manual reconnection from an error terminated connection without reconnection
+        connection.connect();
+
+        // Executes some server interaction testing the connection
+        executeSomeServerInteraction(connection);
+    }
+
+    /**
+     * Tests a manual reconnection after a login.
+     * Closes the connection and then reconnects.
+     */
+    public void testCloseAndManualReconnection() throws Exception {
+        XMPPTCPConnection connection = getConnection(0);
+        String username = connection.getConfiguration().getUsername();
+        String password = connection.getConfiguration().getPassword();
+        XMPPTCPConnectionTestListener listener = new XMPPConnectionTestListener();
+        connection.addConnectionListener(listener);
+
+        // Produces a normal disconnection
+        connection.disconnect();
+        assertEquals("ConnectionListener.connectionClosed() was not notified",
+                true, listener.connectionClosed);
+        // Waits 10 seconds waiting for a reconnection that must not happened.
+        Thread.sleep(MIN_RECONNECT_WAIT * 1000);
+        assertEquals("The connection was stablished but it was not allowed to", false,
+                listener.reconnected);
+
+        // Makes a manual reconnection
+        connection.connect();
+        connection.login(username, password);
+
+        // Executes some server interaction testing the connection
+        executeSomeServerInteraction(connection);
+    }
+
+    /**
+     * Tests a reconnection in a anonymously logged connection.
+     * Closes the connection and then reconnects.
+     */
+    public void testAnonymousReconnection() throws Exception {
+        XMPPTCPConnection connection = createConnection();
+        connection.connect();
+        XMPPTCPConnectionTestListener listener = new XMPPConnectionTestListener();
+        connection.addConnectionListener(listener);
+
+        // Makes the anounymous login
+        connection.loginAnonymously();
+
+        // Produces a normal disconnection
+        connection.disconnect();
+        assertEquals("ConnectionListener.connectionClosed() was not notified",
+                true, listener.connectionClosed);
+        // Makes a manual reconnection
+        connection.connect();
+        connection.loginAnonymously();
+        assertEquals("Failed the manual connection", true, connection.isAnonymous());
+    }
+
+    private XMPPTCPConnection createXMPPConnection() throws Exception {
+        XMPPTCPConnection connection;
+        // Create the configuration
+        ConnectionConfiguration config = new ConnectionConfiguration(getHost(), getPort());
+        config.setCompressionEnabled(Boolean.getBoolean("test.compressionEnabled"));
+        config.setSASLAuthenticationEnabled(true);
+        connection = new XMPPTCPConnection(config);
+
+        return connection;
+    }
+
+    /**
+     * Execute some server interaction in order to test that the regenerated connection works fine.
+     */
+    private void executeSomeServerInteraction(TCPConnection connection) throws XMPPException {
+        PingManager pingManager = PingManager.getInstanceFor(connection);
+        pingManager.pingMyServer();
+    }
+
+    protected int getMaxConnections() {
+        return 1;
+    }
+
+    private class XMPPTCPConnectionTestListener implements ConnectionListener {
+
+        // Variables to support listener notifications verification
+        private volatile boolean connectionClosed = false;
+        private volatile boolean connectionClosedOnError = false;
+        private volatile boolean reconnected = false;
+        private volatile boolean reconnectionFailed = false;
+        private volatile int remainingSeconds = 0;
+        private volatile int attemptsNotifications = 0;
+        private volatile boolean reconnectionCanceled = false;
+        private CountDownLatch countDownLatch;
+
+        private XMPPTCPConnectionTestListener(CountDownLatch latch) {
+            countDownLatch = latch; 
+        }
+
+        private XMPPTCPConnectionTestListener() {
+        }
+        /**
+         * Methods to test the listener.
+         */
+        public void connectionClosed() {
+            connectionClosed = true;
+            
+            if (countDownLatch != null)
+                countDownLatch.countDown();
+        }
+
+        public void connectionClosedOnError(Exception e) {
+            connectionClosedOnError = true;
+        }
+
+        public void reconnectionCanceled() {
+            reconnectionCanceled = true;
+
+            if (countDownLatch != null)
+                countDownLatch.countDown();
+        }
+
+        public void reconnectingIn(int seconds) {
+            attemptsNotifications = attemptsNotifications + 1;
+            remainingSeconds = seconds;
+        }
+
+        public void reconnectionSuccessful() {
+            reconnected = true;
+
+            if (countDownLatch != null)
+                countDownLatch.countDown();
+        }
+
+        public void reconnectionFailed(Exception error) {
+            reconnectionFailed = true;
+
+            if (countDownLatch != null)
+                countDownLatch.countDown();
+        }
+    }
+
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/RosterInitializedBeforeConnectTest.java

@@ -0,0 +1,48 @@
+/**
+ *
+ * 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.smack;
+
+/**
+ * Run all tests defined in RosterTest but initialize the roster before connection is logged in and
+ * authenticated.
+ * 
+ * @author Henning Staib
+ */
+public class RosterInitializedBeforeConnectTest extends RosterSmackTest {
+
+    public RosterInitializedBeforeConnectTest(String name) {
+        super(name);
+    }
+
+    protected boolean createOfflineConnections() {
+        return true;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        // initialize all rosters before login
+        for (int i = 0; i < getMaxConnections(); i++) {
+            XMPPTCPConnection connection = getConnection(i);
+            assertFalse(connection.isConnected());
+
+            Roster roster = connection.getRoster();
+            assertNotNull(roster);
+
+            connectAndLogin(i);
+        }
+    }
+
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/RosterListenerTest.java

@@ -0,0 +1,206 @@
+/**
+ *
+ * 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.smack;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smack.test.SmackTestCase;
+
+/**
+ * Test cases for adding the {@link RosterListener} in different connection states.
+ * 
+ * @author Henning Staib
+ */
+public class RosterListenerTest extends SmackTestCase {
+
+    public RosterListenerTest(String arg0) {
+        super(arg0);
+    }
+
+    public void testAddingRosterListenerBeforeConnect() throws Exception {
+        int inviterIndex = 0;
+        int inviteeIndex = 1;
+        XMPPTCPConnection inviterConnection = getConnection(inviterIndex);
+        connectAndLogin(inviterIndex);
+
+        assertTrue("Inviter is not online", inviterConnection.isConnected());
+
+        Roster inviterRoster = inviterConnection.getRoster();
+
+        // add user1 to roster to create roster events stored at XMPP server
+        inviterRoster.createEntry(getBareJID(inviteeIndex), getUsername(inviteeIndex), null);
+
+        XMPPTCPConnection inviteeConnection = getConnection(inviteeIndex);
+        assertFalse("Invitee is already online", inviteeConnection.isConnected());
+
+        // collector for added entries
+        final List<String> addedEntries = new ArrayList<String>();
+
+        // register roster listener before login
+        Roster inviteeRoster = inviteeConnection.getRoster();
+        inviteeRoster.addRosterListener(new RosterListener() {
+
+            public void presenceChanged(Presence presence) {
+                // ignore
+            }
+
+            public void entriesUpdated(Collection<String> addresses) {
+                // ignore
+            }
+
+            public void entriesDeleted(Collection<String> addresses) {
+                // ignore
+            }
+
+            public void entriesAdded(Collection<String> addresses) {
+                addedEntries.addAll(addresses);
+            }
+        });
+
+        // connect after adding the listener
+        connectAndLogin(inviteeIndex);
+
+        Thread.sleep(5000); // wait for packets to be processed
+
+        assertNotNull("inviter is not in roster", inviteeRoster.getEntry(getBareJID(inviterIndex)));
+
+        assertTrue("got no event for adding inviter",
+                        addedEntries.contains(getBareJID(inviterIndex)));
+
+    }
+
+    public void testAddingRosterListenerAfterConnect() throws Exception {
+        int inviterIndex = 0;
+        int inviteeIndex = 1;
+        XMPPTCPConnection inviterConnection = getConnection(inviterIndex);
+        connectAndLogin(inviterIndex);
+        assertTrue("Inviter is not online", inviterConnection.isConnected());
+
+        Roster inviterRoster = inviterConnection.getRoster();
+
+        // add user1 to roster to create roster events stored at XMPP server
+        inviterRoster.createEntry(getBareJID(inviteeIndex), getUsername(inviteeIndex), null);
+
+        Thread.sleep(500); // wait for XMPP server
+
+        XMPPTCPConnection inviteeConnection = getConnection(inviteeIndex);
+        connectAndLogin(inviteeIndex);
+        assertTrue("Invitee is not online", inviteeConnection.isConnected());
+
+        // collector for added entries
+        final List<String> addedEntries = new ArrayList<String>();
+
+        // wait to simulate concurrency before adding listener
+        Thread.sleep(200);
+
+        // register roster listener after login
+        Roster inviteeRoster = inviteeConnection.getRoster();
+        inviteeRoster.addRosterListener(new RosterListener() {
+
+            public void presenceChanged(Presence presence) {
+                // ignore
+            }
+
+            public void entriesUpdated(Collection<String> addresses) {
+                // ignore
+            }
+
+            public void entriesDeleted(Collection<String> addresses) {
+                // ignore
+            }
+
+            public void entriesAdded(Collection<String> addresses) {
+                addedEntries.addAll(addresses);
+            }
+        });
+
+        Thread.sleep(500); // wait for packets to be processed
+
+        assertNotNull("Inviter is not in roster", inviteeRoster.getEntry(getBareJID(inviterIndex)));
+
+        assertFalse("got event for adding inviter", addedEntries.contains(getBareJID(inviterIndex)));
+
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        cleanUpRoster();
+        super.tearDown();
+    }
+
+    protected int getMaxConnections() {
+        return 2;
+    }
+
+    protected boolean createOfflineConnections() {
+        return true;
+    }
+
+    /**
+     * Clean up all the entries in the roster
+     */
+    private void cleanUpRoster() {
+        for (int i = 0; i < getMaxConnections(); i++) {
+            // Delete all the entries from the roster
+            Roster roster = getConnection(i).getRoster();
+            for (RosterEntry entry : roster.getEntries()) {
+                try {
+                    roster.removeEntry(entry);
+                    Thread.sleep(100);
+                }
+                catch (XMPPException e) {
+                    e.printStackTrace();
+                    fail(e.getMessage());
+                }
+                catch (InterruptedException e) {
+                    // ignore
+                }
+            }
+
+            try {
+                Thread.sleep(700);
+            }
+            catch (InterruptedException e) {
+                fail(e.getMessage());
+            }
+        }
+        // Wait up to 6 seconds to receive roster removal notifications
+        long initial = System.currentTimeMillis();
+        while (System.currentTimeMillis() - initial < 6000
+                        && (getConnection(0).getRoster().getEntryCount() != 0 || getConnection(1).getRoster().getEntryCount() != 0)) {
+            try {
+                Thread.sleep(100);
+            }
+            catch (InterruptedException e) {
+            }
+        }
+
+        assertEquals("Wrong number of entries in connection 0", 0,
+                        getConnection(0).getRoster().getEntryCount());
+        assertEquals("Wrong number of groups in connection 0", 0,
+                        getConnection(0).getRoster().getGroupCount());
+
+        assertEquals("Wrong number of entries in connection 1", 0,
+                        getConnection(1).getRoster().getEntryCount());
+        assertEquals("Wrong number of groups in connection 1", 0,
+                        getConnection(1).getRoster().getGroupCount());
+
+    }
+
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/RosterSmackTest.java

@@ -0,0 +1,710 @@
+/**
+ *
+ * Copyright 2005 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.smack;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.jivesoftware.smack.packet.Presence;
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.jivesoftware.smack.util.StringUtils;
+import org.mockito.internal.util.RemoveFirstLine;
+
+/**
+ * Tests the Roster functionality by creating and removing roster entries.
+ *
+ * @author Gaston Dombiak
+ */
+public class RosterSmackTest extends SmackTestCase {
+
+    /**
+     * Constructor for RosterSmackTest.
+     * @param name
+     */
+    public RosterSmackTest(String name) {
+        super(name);
+    }
+
+    
+    /**
+     * 1. Create entries in roster groups
+     * 2. Iterate on the groups and remove the entry from each group
+     * 3. Check that the entries are kept as unfiled entries
+     */
+    public void testDeleteAllRosterGroupEntries() {
+        try {
+            // Add a new roster entry
+            Roster roster = getConnection(0).getRoster();
+
+            CountDownLatch latch = new CountDownLatch(2);
+            setupCountdown(latch, roster);
+            
+            roster.createEntry(getBareJID(1), "gato11", new String[] { "Friends", "Family" });
+            roster.createEntry(getBareJID(2), "gato12", new String[] { "Family" });
+            
+            waitForCountdown(latch, roster, 2);
+
+            final CountDownLatch removeLatch = new CountDownLatch(3);
+            RosterListener latchCounter = new RosterListener() {
+                @Override
+                public void presenceChanged(Presence presence) {}
+                
+                @Override
+                public void entriesUpdated(Collection<String> addresses) {
+                    removeLatch.countDown();
+                }
+                
+                @Override
+                public void entriesDeleted(Collection<String> addresses) {}
+                
+                @Override
+                public void entriesAdded(Collection<String> addresses) {}
+            }; 
+            
+            roster.addRosterListener(latchCounter);
+
+            for (RosterEntry entry : roster.getEntries()) {
+                for (RosterGroup rosterGroup : entry.getGroups()) {
+                    rosterGroup.removeEntry(entry);
+                }
+            }
+            
+            removeLatch.await(5, TimeUnit.SECONDS);
+            roster.removeRosterListener(latchCounter);
+            
+            assertEquals("The number of entries in connection 1 should be 1", 1, getConnection(1).getRoster().getEntryCount());
+            assertEquals("The number of groups in connection 1 should be 0", 0, getConnection(1).getRoster().getGroupCount());
+            assertEquals("The number of entries in connection 2 should be 1", 1, getConnection(2).getRoster().getEntryCount());
+            assertEquals("The number of groups in connection 2 should be 0", 0, getConnection(2).getRoster().getGroupCount());
+            assertEquals("The number of entries in connection 0 should be 2", 2, roster.getEntryCount());
+            assertEquals("The number of groups in connection 0 should be 0", 0, roster.getGroupCount());
+        }
+        catch (Exception e) {
+            fail(e.getMessage());
+        }
+    }
+
+    private void setupCountdown(final CountDownLatch latch, Roster roster) {
+        roster.addRosterListener(new RosterListener() {
+            
+            @Override
+            public void presenceChanged(Presence presence) {}
+            
+            @Override
+            public void entriesUpdated(Collection<String> addresses) {
+                latch.countDown();
+            }
+            
+            @Override
+            public void entriesDeleted(Collection<String> addresses) {}
+            
+            @Override
+            public void entriesAdded(Collection<String> addresses) {}
+        });
+    }
+
+    private void waitForCountdown(CountDownLatch latch, Roster roster, int entryCount) throws InterruptedException {
+        latch.await(5, TimeUnit.SECONDS);
+        assertEquals(entryCount, roster.getEntryCount());
+    }
+
+    /**
+     * 1. Create entries in roster groups
+     * 2. Iterate on all the entries and remove them from the roster
+     * 3. Check that the number of entries and groups is zero
+     */
+    public void testDeleteAllRosterEntries() throws Exception {
+        // Add a new roster entry
+        Roster roster = getConnection(0).getRoster();
+        
+        CountDownLatch latch = new CountDownLatch(2);
+        setupCountdown(latch, roster);
+        
+        roster.createEntry(getBareJID(1), "gato11", new String[] { "Friends" });
+        roster.createEntry(getBareJID(2), "gato12", new String[] { "Family" });
+
+        waitForCountdown(latch, roster, 2);
+
+        CountDownLatch removeLatch = new CountDownLatch(2);
+        RosterListener latchCounter = new RemovalListener(removeLatch);
+        roster.addRosterListener(latchCounter);
+
+        for (RosterEntry entry : roster.getEntries()) {
+            roster.removeEntry(entry);
+        }
+
+        removeLatch.await(5, TimeUnit.SECONDS);
+        roster.removeRosterListener(latchCounter);
+
+        assertEquals("Wrong number of entries in connection 0", 0, roster.getEntryCount());
+        assertEquals("Wrong number of groups in connection 0", 0, roster.getGroupCount());
+        assertEquals("Wrong number of entries in connection 1", 0, getConnection(1).getRoster().getEntryCount());
+        assertEquals("Wrong number of groups in connection 1", 0, getConnection(1).getRoster().getGroupCount());
+    }
+
+    /**
+     * 1. Create unfiled entries
+     * 2. Iterate on all the entries and remove them from the roster
+     * 3. Check that the number of entries and groups is zero
+     */
+    public void testDeleteAllUnfiledRosterEntries() {
+        try {
+            // Add a new roster entry
+            Roster roster = getConnection(0).getRoster();
+            
+            CountDownLatch latch = new CountDownLatch(2);
+            setupCountdown(latch, roster);
+            
+            roster.createEntry(getBareJID(1), "gato11", null);
+            roster.createEntry(getBareJID(2), "gato12", null);
+
+            waitForCountdown(latch, roster, 2);
+            CountDownLatch removeLatch = new CountDownLatch(2);
+            RosterListener latchCounter = new RemovalListener(removeLatch);
+            roster.addRosterListener(latchCounter);
+
+            for (RosterEntry entry : roster.getEntries()) {
+                roster.removeEntry(entry);
+            }
+
+            removeLatch.await(5, TimeUnit.SECONDS);
+            roster.removeRosterListener(latchCounter);
+
+            assertEquals("Wrong number of entries in connection 0", 0, roster.getEntryCount());
+            assertEquals("Wrong number of groups in connection 0", 0, roster.getGroupCount());
+            assertEquals("Wrong number of entries in connection 1", 0, getConnection(1).getRoster().getEntryCount());
+            assertEquals("Wrong number of groups in connection 1", 0, getConnection(1).getRoster().getGroupCount());
+        }
+        catch (Exception e) {
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * 1. Create an unfiled entry
+     * 2. Change its name
+     * 3. Check that the name has been modified
+     * 4. Reload the whole roster
+     * 5. Check that the name has been modified
+     */
+    public void testChangeNameToUnfiledEntry() {
+        try {
+            // Add a new roster entry
+            Roster roster = getConnection(0).getRoster();
+            CountDownLatch latch = new CountDownLatch(1);
+            setupCountdown(latch, roster);
+            
+            roster.createEntry(getBareJID(1), null, null);
+            
+            waitForCountdown(latch, roster, 1);
+
+            final CountDownLatch updateLatch = new CountDownLatch(2);
+            RosterListener latchCounter = new RosterListener() {
+                @Override
+                public void entriesAdded(Collection<String> addresses) {}
+
+                @Override
+                public void entriesUpdated(Collection<String> addresses) {
+                    updateLatch.countDown();
+                }
+
+                @Override
+                public void entriesDeleted(Collection<String> addresses) {}
+
+                @Override
+                public void presenceChanged(Presence presence) {}
+            };
+            roster.addRosterListener(latchCounter);
+
+            // Change the roster entry name and check if the change was made
+            for (RosterEntry entry : roster.getEntries()) {
+                entry.setName("gato11");
+                assertEquals("gato11", entry.getName());
+            }
+            // Reload the roster and check the name again
+            roster.reload();
+            
+            updateLatch.await(5, TimeUnit.SECONDS);
+            
+            for (RosterEntry entry : roster.getEntries()) {
+                assertEquals("gato11", entry.getName());
+            }
+        }
+        catch (Exception e) {
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * 1. Create an unfiled entry with no name
+     * 2. Check that the the entry does not belong to any group
+     * 3. Change its name and add it to a group
+     * 4. Check that the name has been modified and that the entry belongs to a group
+     */
+    public void testChangeGroupAndNameToUnfiledEntry() {
+        try {
+            // Add a new roster entry
+            Roster roster = getConnection(0).getRoster();
+            roster.createEntry(getBareJID(1), null, null);
+
+            Thread.sleep(500);
+
+            getConnection(1).getRoster().createEntry(getBareJID(0), null, null);
+
+            // Wait up to 5 seconds to receive presences of the new roster contacts
+            long initial = System.currentTimeMillis();
+            while (System.currentTimeMillis() - initial < 5000 &&
+                    !roster.getPresence(getBareJID(0)).isAvailable()) {
+                Thread.sleep(100);
+            }
+            //assertNotNull("Presence not received", roster.getPresence(getBareJID(0)));
+
+            for (RosterEntry entry : roster.getEntries()) {
+                assertFalse("The roster entry belongs to a group", !entry.getGroups().isEmpty());
+            }
+
+            // Change the roster entry name and check if the change was made
+            roster.createEntry(getBareJID(1), "NewName", new String[] { "Friends" });
+
+            // Reload the roster and check the name again
+            Thread.sleep(200);
+            for (RosterEntry entry : roster.getEntries()) {
+                assertEquals("Name of roster entry is wrong", "NewName", entry.getName());
+                assertTrue("The roster entry does not belong to any group", !entry.getGroups().isEmpty());
+            }
+            // Wait up to 5 seconds to receive presences of the new roster contacts
+            initial = System.currentTimeMillis();
+            while (System.currentTimeMillis() - initial < 5000 &&
+                    !roster.getPresence(getBareJID(1)).isAvailable()) {
+                Thread.sleep(100);
+            }
+            assertTrue("Presence not received", roster.getPresence(getBareJID(1)).isAvailable());
+        } catch (Exception e) {
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * Tests that adding an existing roster entry that belongs to a group to another group
+     * works fine.
+     */
+    public void testAddEntryToNewGroup() {
+        try {
+            Thread.sleep(500);
+
+            // Add a new roster entry
+            Roster roster = getConnection(0).getRoster();
+            roster.createEntry(getBareJID(1), "gato11", new String[] { "Friends" });
+            roster.createEntry(getBareJID(2), "gato12", new String[] { "Family" });
+
+            // Wait up to 2 seconds to receive new roster contacts
+            long initial = System.currentTimeMillis();
+            while (System.currentTimeMillis() - initial < 2000  && roster.getEntryCount() != 2) {
+                Thread.sleep(100);
+            }
+
+            assertEquals("Wrong number of entries in connection 0", 2, roster.getEntryCount());
+
+            // Add "gato11" to a new group called NewGroup
+            roster.createGroup("NewGroup").addEntry(roster.getEntry(getBareJID(1)));
+
+
+            // Log in from another resource so we can test the roster
+            XMPPTCPConnection con2 = createConnection();
+            con2.connect();
+            con2.login(getUsername(0), getUsername(0), "MyNewResource");
+
+            Roster roster2 = con2.getRoster();
+
+            assertEquals("Wrong number of entries in new connection", 2, roster2.getEntryCount());
+            assertEquals("Wrong number of groups in new connection", 3, roster2.getGroupCount());
+
+
+            RosterEntry entry = roster2.getEntry(getBareJID(1));
+            assertNotNull("No entry for user 1 was found", entry);
+
+            List<String> groupNames = new ArrayList<String>();
+            for (RosterGroup rosterGroup : entry.getGroups()) {
+                groupNames.add(rosterGroup.getName());
+            }
+            assertTrue("Friends group was not found", groupNames.contains("Friends"));
+            assertTrue("NewGroup group was not found", groupNames.contains("NewGroup"));
+
+            // Close the new connection
+            con2.disconnect();
+            Thread.sleep(500);
+        }
+        catch (Exception e) {
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * Test if renaming a roster group works fine.
+     *
+     */
+    public void testRenameRosterGroup() {
+        try {
+            Thread.sleep(200);
+
+            // Add a new roster entry
+            Roster roster = getConnection(0).getRoster();
+            roster.createEntry(getBareJID(1), "gato11", new String[] { "Friends" });
+            roster.createEntry(getBareJID(2), "gato12", new String[] { "Friends" });
+
+            // Wait up to 2 seconds to let the server process presence subscriptions
+            long initial = System.currentTimeMillis();
+            while (System.currentTimeMillis() - initial < 2000 && (
+                    !roster.getPresence(getBareJID(1)).isAvailable() ||
+                            !roster.getPresence(getBareJID(2)).isAvailable())) {
+                Thread.sleep(100);
+            }
+
+            roster.getGroup("Friends").setName("Amigos");
+
+            // Wait up to 2 seconds
+            initial = System.currentTimeMillis();
+            while (System.currentTimeMillis() - initial < 2000 &&
+                    (roster.getGroup("Friends") != null)) {
+                Thread.sleep(100);
+            }
+
+            assertNull("The group Friends still exists", roster.getGroup("Friends"));
+            assertNotNull("The group Amigos does not exist", roster.getGroup("Amigos"));
+            assertEquals(
+                "Wrong number of entries in the group Amigos",
+                2,
+                roster.getGroup("Amigos").getEntryCount());
+
+            // Setting the name to empty is like removing this group
+            roster.getGroup("Amigos").setName("");
+
+            // Wait up to 2 seconds for the group to change its name
+            initial = System.currentTimeMillis();
+            while (System.currentTimeMillis() - initial < 2000 &&
+                    (roster.getGroup("Amigos") != null)) {
+                Thread.sleep(100);
+            }
+
+            assertNull("The group Amigos still exists", roster.getGroup("Amigos"));
+            assertNull("The group with no name does exist", roster.getGroup(""));
+            assertEquals("There are still groups in the roster", 0, roster.getGroupCount());
+            assertEquals(
+                "Wrong number of unfiled entries",
+                2,
+                roster.getUnfiledEntryCount());
+
+            Thread.sleep(200);
+        }
+        catch (Exception e) {
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * Test presence management.<p>
+     * 
+     * 1. Log in user0 from a client and user1 from 2 clients
+     * 2. Create presence subscription of type BOTH between 2 users
+     * 3. Check that presence is correctly delivered to both users
+     * 4. User1 logs out from a client
+     * 5. Check that presence for each connected resource is correct
+     */
+    public void testRosterPresences() throws Exception {
+        Presence presence;
+
+        // Create another connection for the same user of connection 1
+        ConnectionConfiguration connectionConfiguration =
+                new ConnectionConfiguration(getHost(), getPort(), getServiceName());
+        XMPPTCPConnection conn4 = new XMPPConnection(connectionConfiguration);
+        conn4.connect();
+        conn4.login(getUsername(1), getPassword(1), "Home");
+
+        // Add a new roster entry
+        Roster roster = getConnection(0).getRoster();
+        roster.createEntry(getBareJID(1), "gato11", null);
+
+        // Wait up to 2 seconds
+        long initial = System.currentTimeMillis();
+        while (System.currentTimeMillis() - initial < 2000 &&
+                (roster.getPresence(getBareJID(1)).getType() == Presence.Type.unavailable)) {
+            Thread.sleep(100);
+        }
+
+        // Check that a presence is returned for a user
+        presence = roster.getPresence(getBareJID(1));
+        assertTrue("Returned a null Presence for an existing user", presence.isAvailable());
+
+        // Check that the right presence is returned for a user+resource
+        presence = roster.getPresenceResource(getUsername(1) + "@" + conn4.getServiceName() + "/Home");
+        assertEquals("Returned the wrong Presence", "Home",
+                StringUtils.parseResource(presence.getFrom()));
+
+        // Check that the right presence is returned for a user+resource
+        presence = roster.getPresenceResource(getFullJID(1));
+        assertTrue("Presence not found for user " + getFullJID(1), presence.isAvailable());
+        assertEquals("Returned the wrong Presence", "Smack",
+                StringUtils.parseResource(presence.getFrom()));
+
+        // Check the returned presence for a non-existent user+resource
+        presence = roster.getPresenceResource("noname@" + getServiceName() + "/Smack");
+        assertFalse("Available presence was returned for a non-existing user", presence.isAvailable());
+        assertEquals("Returned Presence for a non-existing user has the incorrect type",
+                Presence.Type.unavailable, presence.getType());
+
+        // Check that the returned presences are correct
+        Iterator<Presence> presences = roster.getPresences(getBareJID(1));
+        int count = 0;
+        while (presences.hasNext()) {
+            count++;
+            presences.next();
+        }
+        assertEquals("Wrong number of returned presences", count, 2);
+
+        // Close the connection so one presence must go
+        conn4.disconnect();
+
+        // Check that the returned presences are correct
+        presences = roster.getPresences(getBareJID(1));
+        count = 0;
+        while (presences.hasNext()) {
+            count++;
+            presences.next();
+        }
+        assertEquals("Wrong number of returned presences", count, 1);
+    }
+
+    /**
+     * User1 is connected from 2 resources. User1 adds User0 to his roster. Ensure
+     * that both resources of user1 get the available presence of User0. Remove User0
+     * from User1's roster and check presences again.
+     */
+    public void testMultipleResources() throws Exception {
+        // Create another connection for the same user of connection 1
+        ConnectionConfiguration connectionConfiguration =
+                new ConnectionConfiguration(getHost(), getPort(), getServiceName());
+        XMPPTCPConnection conn4 = new XMPPConnection(connectionConfiguration);
+        conn4.connect();
+        conn4.login(getUsername(1), getPassword(1), "Home");
+
+        // Add a new roster entry
+        Roster roster = conn4.getRoster();
+        roster.createEntry(getBareJID(0), "gato11", null);
+
+        // Wait up to 2 seconds
+        long initial = System.currentTimeMillis();
+        while (System.currentTimeMillis() - initial < 2000 && (
+                !roster.getPresence(getBareJID(0)).isAvailable() ||
+                        !getConnection(1).getRoster().getPresence(getBareJID(0)).isAvailable())) {
+            Thread.sleep(100);
+        }
+
+        // Check that a presence is returned for the new contact
+        Presence presence = roster.getPresence(getBareJID(0));
+        assertTrue("Returned a null Presence for an existing user", presence.isAvailable());
+
+        // Check that a presence is returned for the new contact
+        presence = getConnection(1).getRoster().getPresence(getBareJID(0));
+        assertTrue("Returned a null Presence for an existing user", presence.isAvailable());
+
+        // Delete user from roster
+        roster.removeEntry(roster.getEntry(getBareJID(0)));
+
+        // Wait up to 2 seconds
+        initial = System.currentTimeMillis();
+        while (System.currentTimeMillis() - initial < 2000 && (
+                roster.getPresence(getBareJID(0)).getType() != Presence.Type.unavailable ||
+                        getConnection(1).getRoster().getPresence(getBareJID(0)).getType() !=
+                                Presence.Type.unavailable)) {
+            Thread.sleep(100);
+        }
+
+        // Check that no presence is returned for the removed contact
+        presence = roster.getPresence(getBareJID(0));
+        assertFalse("Available presence was returned for removed contact", presence.isAvailable());
+        assertEquals("Returned Presence for removed contact has incorrect type",
+                Presence.Type.unavailable, presence.getType());
+
+        // Check that no presence is returned for the removed contact
+        presence = getConnection(1).getRoster().getPresence(getBareJID(0));
+        assertFalse("Available presence was returned for removed contact", presence.isAvailable());
+        assertEquals("Returned Presence for removed contact has incorrect type",
+                Presence.Type.unavailable, presence.getType());
+    }
+
+    /**
+     * Tests that the server and Smack are able to handle nicknames that include
+     * < > characters.
+     */
+    public void testNotCommonNickname() throws Exception {
+        // Add a new roster entry
+        Roster roster = getConnection(0).getRoster();
+        roster.createEntry(getBareJID(1), "Thiago <12001200>", null);
+
+        Thread.sleep(500);
+
+        assertEquals("Created entry was never received", 1, roster.getEntryCount());
+
+        // Create another connection for the same user of connection 0
+        ConnectionConfiguration connectionConfiguration =
+                new ConnectionConfiguration(getHost(), getPort(), getServiceName());
+        XMPPTCPConnection conn2 = new XMPPConnection(connectionConfiguration);
+        conn2.connect();
+        conn2.login(getUsername(0), getPassword(0), "Home");
+
+        // Retrieve roster and verify that new contact is there and nickname is correct
+        Roster roster2 = conn2.getRoster();
+        assertEquals("Created entry was never received", 1, roster2.getEntryCount());
+        RosterEntry entry = roster2.getEntry(getBareJID(1));
+        assertNotNull("New entry was not returned from the server", entry);
+        assertEquals("Roster item name is incorrect", "Thiago <12001200>", entry.getName());
+    }
+
+    /**
+     * Clean up all the entries in the roster
+     */
+    private void cleanUpRoster() {
+        for (int i=0; i<getMaxConnections(); i++) {
+            // Delete all the entries from the roster
+            Roster roster = getConnection(i).getRoster();
+            final CountDownLatch removalLatch = new CountDownLatch(roster.getEntryCount());
+            roster.addRosterListener(new RosterListener() {
+                
+                @Override
+                public void presenceChanged(Presence presence) {}
+                
+                @Override
+                public void entriesUpdated(Collection<String> addresses) {}
+                
+                @Override
+                public void entriesDeleted(Collection<String> addresses) {
+                    removalLatch.countDown();
+                }
+                
+                @Override
+                public void entriesAdded(Collection<String> addresses) {}
+            });
+            
+            for (RosterEntry entry : roster.getEntries()) {
+                try {
+                    roster.removeEntry(entry);
+                }
+                catch (XMPPException e) {
+                    e.printStackTrace();
+                    fail(e.getMessage());
+                }
+            }
+
+            try  {
+                removalLatch.await(5, TimeUnit.SECONDS);
+            }
+            catch (InterruptedException e) {
+                fail(e.getMessage());
+            }
+        }
+
+        assertEquals("Wrong number of entries in connection 0", 0, getConnection(0).getRoster().getEntryCount());
+        assertEquals("Wrong number of entries in connection 1", 0, getConnection(1).getRoster().getEntryCount());
+        assertEquals("Wrong number of entries in connection 2", 0, getConnection(2).getRoster().getEntryCount());
+    }
+
+    /**
+     * Tests the creation of a roster and then simulates abrupt termination. Cached presences
+     * must go offline. At reconnection, presences must go back to online.
+     * <ol>
+     *     <li> Create some entries
+     *     <li> Breack the connection
+     *     <li> Check offline presences
+     *     <li> Whait for automatic reconnection
+     *     <li> Check online presences
+     * </ol>
+     */
+    public void testOfflinePresencesAfterDisconnection() throws Exception {
+        // Add a new roster entry
+        Roster roster = getConnection(0).getRoster();
+        roster.createEntry(getBareJID(1), "gato11", null);
+        roster.createEntry(getBareJID(2), "gato12", null);
+
+        // Wait up to 2 seconds to let the server process presence subscriptions
+        long initial = System.currentTimeMillis();
+        while (System.currentTimeMillis() - initial < 2000 && (
+                !roster.getPresence(getBareJID(1)).isAvailable() ||
+                        !roster.getPresence(getBareJID(2)).isAvailable())) {
+            Thread.sleep(100);
+        }
+
+        Thread.sleep(200);
+
+        // Break the connection
+        getConnection(0).notifyConnectionError(new Exception("Simulated Error"));
+
+        Presence presence = roster.getPresence(getBareJID(1));
+        assertFalse("Unavailable presence not found for offline user", presence.isAvailable());
+        assertEquals("Unavailable presence not found for offline user", Presence.Type.unavailable,
+                presence.getType());
+        // Reconnection should occur in 10 seconds
+        Thread.sleep(12200);
+        presence = roster.getPresence(getBareJID(1));
+        assertTrue("Presence not found for user", presence.isAvailable());
+        assertEquals("Presence should be online after a connection reconnection",
+                Presence.Type.available, presence.getType());
+    }
+    
+    protected int getMaxConnections() {
+        return 3;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        cleanUpRoster();
+    }
+
+
+    @Override
+    protected void tearDown() throws Exception {
+        cleanUpRoster();
+        super.tearDown();
+    }
+    
+    private class RemovalListener implements RosterListener {
+        private CountDownLatch latch;
+        
+        private RemovalListener(CountDownLatch removalLatch) {
+            latch = removalLatch;
+        }
+        
+        @Override
+        public void presenceChanged(Presence presence) {}
+        
+        @Override
+        public void entriesUpdated(Collection<String> addresses) {}
+        
+        @Override
+        public void entriesDeleted(Collection<String> addresses) {                
+            latch.countDown();
+        }
+        
+        @Override
+        public void entriesAdded(Collection<String> addresses) {}
+    }; 
+
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/filter/AndFilterTest.java

@@ -0,0 +1,64 @@
+/**
+ *
+ * Copyright 2003 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.smack.filter;
+
+import junit.framework.TestCase;
+import org.jivesoftware.smack.packet.*;
+
+/**
+ * A test case for the AndFilter class.
+ */
+public class AndFilterTest extends TestCase {
+
+    public void testNullArgs() {
+        PacketFilter filter = null;
+        try {
+            new AndFilter(filter, filter);
+            fail("Should have thrown IllegalArgumentException");
+        }
+        catch (IllegalArgumentException e) {
+            assertTrue(true);
+        }
+    }
+
+    public void testAccept() {
+        MockPacketFilter trueFilter = new MockPacketFilter(true);
+        MockPacketFilter falseFilter = new MockPacketFilter(false);
+
+        MockPacket packet = new MockPacket();
+
+        AndFilter andFilter = new AndFilter(trueFilter, trueFilter);
+        assertTrue(andFilter.accept(packet));
+
+        andFilter = new AndFilter(trueFilter, falseFilter);
+        assertFalse(andFilter.accept(packet));
+
+        andFilter = new AndFilter(falseFilter, trueFilter);
+        assertFalse(andFilter.accept(packet));
+
+        andFilter = new AndFilter(falseFilter, falseFilter);
+        assertFalse(andFilter.accept(packet));
+
+        andFilter = new AndFilter();
+        andFilter.addFilter(trueFilter);
+        andFilter.addFilter(trueFilter);
+        andFilter.addFilter(falseFilter);
+        andFilter.addFilter(trueFilter);
+        assertFalse(andFilter.accept(packet));
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/filter/FromContainsFilterTest.java

@@ -0,0 +1,69 @@
+/**
+ *
+ * Copyright 2003 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.smack.filter;
+
+import junit.framework.TestCase;
+import org.jivesoftware.smack.packet.*;
+
+/**
+ * A test case for the FromContainsFilter class.
+ */
+public class FromContainsFilterTest extends TestCase {
+
+    public void testNullArgs() {
+        try {
+            new FromContainsFilter(null);
+            fail("Parameter can not be null");
+        }
+        catch (IllegalArgumentException e) {
+            assertTrue(true);
+        }
+    }
+
+    public void testAccept() {
+        MockFromPacket packet = new MockFromPacket("foo@bar.com");
+
+        FromContainsFilter fromContainsFilter = new FromContainsFilter("");
+        assertTrue(fromContainsFilter.accept(packet));
+
+        fromContainsFilter = new FromContainsFilter("foo");
+        assertTrue(fromContainsFilter.accept(packet));
+
+        fromContainsFilter = new FromContainsFilter("foo@bar.com");
+        assertTrue(fromContainsFilter.accept(packet));
+
+        fromContainsFilter = new FromContainsFilter("bar@foo.com");
+        assertFalse(fromContainsFilter.accept(packet));
+
+        fromContainsFilter = new FromContainsFilter("blah-stuff,net");
+        assertFalse(fromContainsFilter.accept(packet));
+    }
+
+    /**
+     * Wraps the MockPacket class to always give an expected From field.
+     */
+    private class MockFromPacket extends MockPacket {
+        private String from;
+        public MockFromPacket(String from) {
+            this.from = from;
+        }
+        public String getFrom() {
+            return from;
+        }
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/filter/NotFilterTest.java

@@ -0,0 +1,51 @@
+/**
+ *
+ * Copyright 2003 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.smack.filter;
+
+import junit.framework.TestCase;
+import org.jivesoftware.smack.packet.*;
+
+/**
+ * A test case for the NotFilter class.
+ */
+public class NotFilterTest extends TestCase {
+
+    public void testNullArgs() {
+        PacketFilter filter = null;
+        try {
+            NotFilter or = new NotFilter(filter);
+            fail("Should have thrown IllegalArgumentException");
+        }
+        catch (IllegalArgumentException e) {
+            assertTrue(true);
+        }
+    }
+
+    public void testAccept() {
+        MockPacketFilter trueFilter = new MockPacketFilter(true);
+        MockPacketFilter falseFilter = new MockPacketFilter(false);
+
+        MockPacket packet = new MockPacket();
+
+        NotFilter NotFilter = new NotFilter(trueFilter);
+        assertFalse(NotFilter.accept(packet));
+
+        NotFilter = new NotFilter(falseFilter);
+        assertTrue(NotFilter.accept(packet));
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/filter/OrFilterTest.java

@@ -0,0 +1,98 @@
+/**
+ *
+ * Copyright 2003 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.smack.filter;
+
+import junit.framework.TestCase;
+import org.jivesoftware.smack.packet.*;
+
+/**
+ * A test case for the OrFilter class.
+ */
+public class OrFilterTest extends TestCase {
+
+    public void testNullArgs() {
+        PacketFilter filter = null;
+        try {
+            OrFilter or = new OrFilter(filter, filter);
+            fail("Should have thrown IllegalArgumentException");
+        }
+        catch (IllegalArgumentException e) {
+            assertTrue(true);
+        }
+    }
+
+    public void testAccept() {
+        MockPacketFilter trueFilter = new MockPacketFilter(true);
+        MockPacketFilter falseFilter = new MockPacketFilter(false);
+
+        MockPacket packet = new MockPacket();
+
+        // Testing TT == T
+        OrFilter orFilter = new OrFilter(trueFilter, trueFilter);
+        assertTrue(orFilter.accept(packet));
+
+        // Testing TF = F
+        orFilter = new OrFilter(trueFilter, falseFilter);
+        assertTrue(orFilter.accept(packet));
+
+        // Testing FT = F
+        orFilter = new OrFilter(falseFilter, trueFilter);
+        assertTrue(orFilter.accept(packet));
+
+        // Testing FF = F
+        orFilter = new OrFilter(falseFilter, falseFilter);
+        assertFalse(orFilter.accept(packet));
+
+        // Testing TTTT = T
+        orFilter = new OrFilter(
+            new OrFilter(trueFilter, trueFilter), new OrFilter(trueFilter, trueFilter)
+        );
+        assertTrue(orFilter.accept(packet));
+
+        // Testing TFTT = F
+        orFilter = new OrFilter(
+            new OrFilter(trueFilter, falseFilter), new OrFilter(trueFilter, trueFilter)
+        );
+        assertTrue(orFilter.accept(packet));
+
+        // Testing TTFT = F
+        orFilter = new OrFilter(
+            new OrFilter(trueFilter, trueFilter), new OrFilter(falseFilter, trueFilter)
+        );
+        assertTrue(orFilter.accept(packet));
+
+        // Testing TTTF = F
+        orFilter = new OrFilter(
+            new OrFilter(trueFilter, trueFilter), new OrFilter(trueFilter, falseFilter)
+        );
+        assertTrue(orFilter.accept(packet));
+
+        // Testing FFFF = F
+        orFilter = new OrFilter(
+            new OrFilter(falseFilter, falseFilter), new OrFilter(falseFilter, falseFilter)
+        );
+        assertFalse(orFilter.accept(packet));
+
+        orFilter = new OrFilter();
+        orFilter.addFilter(trueFilter);
+        orFilter.addFilter(trueFilter);
+        orFilter.addFilter(falseFilter);
+        orFilter.addFilter(trueFilter);
+        assertTrue(orFilter.accept(packet));
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/filter/PacketIDFilterTest.java

@@ -0,0 +1,63 @@
+/**
+ *
+ * Copyright 2003 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.smack.filter;
+
+import junit.framework.TestCase;
+import org.jivesoftware.smack.packet.*;
+
+/**
+ * A test case for the PacketIDFilter class.
+ */
+public class PacketIDFilterTest extends TestCase {
+
+    public void testNullArgs() {
+        try {
+            new PacketIDFilter(null);
+            fail("Parameter can not be null");
+        }
+        catch (IllegalArgumentException e) {
+            assertTrue(true);
+        }
+    }
+
+    public void testAccept() {
+        MockIDPacket packet = new MockIDPacket("foo");
+
+        PacketIDFilter packetIDFilter = new PacketIDFilter("");
+        assertFalse(packetIDFilter.accept(packet));
+
+        packetIDFilter = new PacketIDFilter("foo");
+        assertTrue(packetIDFilter.accept(packet));
+
+        packetIDFilter = new PacketIDFilter("fOO");
+        assertFalse(packetIDFilter.accept(packet));
+    }
+
+    /**
+     * Wraps the MockPacket class to always give an expected packet ID field.
+     */
+    private class MockIDPacket extends MockPacket {
+        private String id;
+        public MockIDPacket(String id) {
+            this.id = id;
+        }
+        public String getPacketID() {
+            return id;
+        }
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/filter/PacketTypeFilterTest.java

@@ -0,0 +1,111 @@
+/**
+ *
+ * Copyright 2003 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.smack.filter;
+
+import junit.framework.TestCase;
+import org.jivesoftware.smack.packet.*;
+
+/**
+ * Test cases for the PacketTypeFilter class.
+ */
+public class PacketTypeFilterTest extends TestCase {
+
+    private class InnerClassDummy {
+        public class DummyPacket extends Packet {
+            public String toXML() {
+                return null;
+            }
+        }
+        public DummyPacket getInnerInstance() {
+            return new DummyPacket();
+        }
+    }
+
+    private static class StaticInnerClassDummy {
+        public static class StaticDummyPacket extends Packet {
+            public String toXML() {
+                return null;
+            }
+        }
+        public static StaticDummyPacket getInnerInstance() {
+            return new StaticDummyPacket();
+        }
+    }
+
+    /**
+     * Test case for the constructor of PacketTypeFilter objects.
+     */
+    public void testConstructor() {
+        // We dont need to test this since PacketTypeFilter(Class<? extends Packet> packetType) only excepts Packets
+        // Test a class that is not a subclass of Packet
+        // try {
+        // new PacketTypeFilter(Dummy.class);
+        // fail("Parameter must be a subclass of Packet.");
+        // }
+        // catch (IllegalArgumentException e) {}
+
+        // Test a class that is a subclass of Packet
+        try {
+            new PacketTypeFilter(MockPacket.class);
+        }
+        catch (IllegalArgumentException e) {
+            fail();
+        }
+
+        // Test another class which is a subclass of Packet
+        try {
+            new PacketTypeFilter(IQ.class);
+        }
+        catch (IllegalArgumentException e) {
+            fail();
+        }
+
+        // Test an internal class which is a subclass of Packet
+        try {
+            new PacketTypeFilter(InnerClassDummy.DummyPacket.class);
+        }
+        catch (IllegalArgumentException e) {
+            fail();
+        }
+
+        // Test an internal static class which is a static subclass of Packet
+        try {
+            new PacketTypeFilter(StaticInnerClassDummy.StaticDummyPacket.class);
+        }
+        catch (IllegalArgumentException e) {
+            fail();
+        }
+    }
+
+    /**
+     * Test case to test the accept() method of PacketTypeFilter objects.
+     */
+    public void testAccept() {
+        Packet packet = new MockPacket();
+        PacketTypeFilter filter = new PacketTypeFilter(MockPacket.class);
+        assertTrue(filter.accept(packet));
+
+        packet = (new InnerClassDummy()).getInnerInstance();
+        filter = new PacketTypeFilter(InnerClassDummy.DummyPacket.class);
+        assertTrue(filter.accept(packet));
+
+        packet = StaticInnerClassDummy.getInnerInstance();
+        filter = new PacketTypeFilter(StaticInnerClassDummy.StaticDummyPacket.class);
+        assertTrue(filter.accept(packet));
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/filter/ToContainsFilterTest.java

@@ -0,0 +1,69 @@
+/**
+ *
+ * Copyright 2003 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.smack.filter;
+
+import junit.framework.TestCase;
+import org.jivesoftware.smack.packet.*;
+
+/**
+ * A test case for the ToContainsFilter class.
+ */
+public class ToContainsFilterTest extends TestCase {
+
+    public void testNullArgs() {
+        try {
+            new ToContainsFilter(null);
+            fail("Parameter can not be null");
+        }
+        catch (IllegalArgumentException e) {
+            assertTrue(true);
+        }
+    }
+
+    public void testAccept() {
+        MockToPacket packet = new MockToPacket("foo@bar.com");
+
+        ToContainsFilter toContainsFilter = new ToContainsFilter("");
+        assertTrue(toContainsFilter.accept(packet));
+
+        toContainsFilter = new ToContainsFilter("foo");
+        assertTrue(toContainsFilter.accept(packet));
+
+        toContainsFilter = new ToContainsFilter("foo@bar.com");
+        assertTrue(toContainsFilter.accept(packet));
+
+        toContainsFilter = new ToContainsFilter("bar@foo.com");
+        assertFalse(toContainsFilter.accept(packet));
+
+        toContainsFilter = new ToContainsFilter("blah-stuff,net");
+        assertFalse(toContainsFilter.accept(packet));
+    }
+
+    /**
+     * Wraps the MockPacket class to always give an expected To field.
+     */
+    private class MockToPacket extends MockPacket {
+        private String to;
+        public MockToPacket(String to) {
+            this.to = to;
+        }
+        public String getTo() {
+            return to;
+        }
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/packet/MockPacket.java

@@ -0,0 +1,32 @@
+/**
+ *
+ * Copyright 2003 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.smack.packet;
+
+/**
+ * A mock implementation of the Packet abstract class. Implements toXML() by returning null.
+ */
+public class MockPacket extends Packet {
+
+    /**
+     * Returns null always.
+     * @return null
+     */
+    public String toXML() {
+        return null;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/packet/MockPacketFilter.java

@@ -0,0 +1,38 @@
+/**
+ *
+ * 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.smack.packet;
+
+import org.jivesoftware.smack.filter.PacketFilter;
+
+/**
+ * A mock implementation of the PacketFilter class. Pass in the value you want the
+ * accept(..) method to return.
+ */
+public class MockPacketFilter implements PacketFilter {
+
+    private boolean acceptValue;
+
+    public MockPacketFilter(boolean acceptValue) {
+        this.acceptValue = acceptValue;
+    }
+
+    public boolean accept(Packet packet) {
+        return acceptValue;
+    }
+
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/packet/PrivacyProviderTest.java

@@ -0,0 +1,384 @@
+/**
+ *
+ * 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.smack.packet;
+
+import org.jivesoftware.smack.provider.PrivacyProvider;
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.xmlpull.v1.XmlPullParserFactory;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.StringReader;
+
+/** 
+ * Test the PrivacyProvider class with valids privacy xmls
+ * 
+ * @author Francisco Vives
+ */
+public class PrivacyProviderTest extends SmackTestCase {
+
+    /**
+     * Constructor for PrivacyTest.
+     * @param arg0
+     */
+    public PrivacyProviderTest(String arg0) {
+        super(arg0);
+    }
+
+	public static void main(String args[]) {
+		try {
+			new PrivacyProviderTest(null).testFull();
+		} catch (Exception e) {
+			e.printStackTrace();
+			System.exit(1);
+		}
+	}
+
+    /**
+     * Check the parser with an xml with all kind of stanzas. 
+     * To create the xml string based from an xml file, replace:\n with:	"\n  + "
+     */
+    public void testFull() {
+        // Make the XML to test
+    	String xml = ""
+    		  + "  <iq type='result' id='getlist2' to='romeo@example.net/orchard'>	"
+    		  + "  <query xmlns='jabber:iq:privacy'>	"
+    		  + "    <active name='testFilter'/>	"
+    		  + "    <default name='testSubscription'/>	"
+    		  + "    <list name='testFilter'>	"
+    		  + "      <item type='jid'	"
+    		  + "            value='tybalt@example.com'	"
+    		  + "            action='deny'	"
+    		  + "            order='1'/>	"
+    		  + "      <item action='allow' order='2'>	"
+    		  + "        <message/>	"
+    		  + "		<presence-in/>	"
+    		  + "		<presence-out/>	"
+    		  + "		<iq/>	"
+    		  + "		</item>	"
+    		  + "    </list>	"
+    		  + "    <list name='testSubscription'>	"
+    		  + "      <item type='subscription'	"
+    		  + "            value='both'	"
+    		  + "            action='allow'	"
+    		  + "            order='10'/>	"
+    		  + "      <item type='subscription'	"
+    		  + "            value='to'	"
+    		  + "            action='allow'	"
+    		  + "            order='11'/>	"
+    		  + "      <item type='subscription'	"
+    		  + "            value='from'	"
+    		  + "            action='allow'	"
+    		  + "            order='12'/>	"
+    		  + "      <item type='subscription'	"
+    		  + "            value='none'	"
+    		  + "            action='deny'	"
+    		  + "            order='5'>	"
+    		  + "        <message/>	"
+    		  + "      </item>	"
+    		  + "      <item action='deny' order='15'/>	"
+    		  + "    </list>	"
+    		  + "    <list name='testJID'>	"
+    		  + "      <item type='jid'	"
+    		  + "            value='juliet@example.com'	"
+    		  + "            action='allow'	"
+    		  + "            order='6'/>	"
+    		  + "      <item type='jid'	"
+    		  + "            value='benvolio@example.org/palm'	"
+    		  + "            action='deny'	"
+    		  + "            order='7'/>	"
+    		  + "      <item type='jid'	"
+    		  + "            action='allow'	"
+    		  + "            order='42'/>	"
+    		  + "      <item action='deny' order='666'/>	"
+    		  + "    </list>	"
+    		  + "    <list name='testGroup'>	"
+    		  + "	      <item type='group'	"
+    		  + "            value='Enemies'	"
+    		  + "            action='deny'	"
+    		  + "            order='4'>	"
+    		  + "		   <message/>	"
+    		  + "		</item>	"
+    		  + "      <item action='deny' order='666'/>	"
+    		  + "    </list>	"
+    		  + "    <list name='testEmpty'/>	"
+    		  + "  </query>	"
+    		  + "  <error type='cancel'>	"
+    		  + "    <item-not-found	"
+    		  + "        xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>	"
+    		  + "  </error>	"
+    		  + "</iq>	";
+
+        try {
+        	// Create the xml parser
+        	XmlPullParser parser = getParserFromXML(xml);
+        	// Create a packet from the xml
+        	Privacy packet = (Privacy) (new PrivacyProvider()).parseIQ(parser);
+        	
+        	// check if it exist
+            assertNotNull(packet);
+            // assertEquals(xml, packet.getChildElementXML());
+            
+            // check the default and active names
+            assertEquals("testFilter", packet.getActiveName());
+            assertEquals("testSubscription", packet.getDefaultName());
+            
+            // check the list
+            assertEquals(2, packet.getPrivacyList("testFilter").size());
+            assertEquals(5, packet.getPrivacyList("testSubscription").size());
+            assertEquals(4, packet.getPrivacyList("testJID").size());
+            assertEquals(2, packet.getPrivacyList("testGroup").size());
+            assertEquals(0, packet.getPrivacyList("testEmpty").size());
+            
+            // check each privacy item
+            PrivacyItem item = packet.getItem("testGroup", 4);
+            assertEquals("Enemies", item.getValue());
+            assertEquals(PrivacyItem.Type.group, item.getType());
+            assertEquals(false, item.isAllow());
+            assertEquals(true, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(false, item.isFilterEverything());
+            
+            item = packet.getItem("testFilter", 1);
+            assertEquals("tybalt@example.com", item.getValue());
+            assertEquals(PrivacyItem.Type.jid, item.getType());
+            assertEquals(false, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+            
+            item = packet.getItem("testFilter", 2);
+            assertEquals(null, item.getValue());
+            assertEquals(null, item.getType());
+            assertEquals(true, item.isAllow());
+            assertEquals(true, item.isFilterMessage());
+            assertEquals(true, item.isFilterIQ());
+            assertEquals(true, item.isFilterPresence_in());
+            assertEquals(true, item.isFilterPresence_out());
+            assertEquals(false, item.isFilterEverything());
+
+            // TEST THE testSubscription LIST
+            item = packet.getItem("testSubscription", 10);
+            assertEquals("both", item.getValue());
+            assertEquals(PrivacyItem.Type.subscription, item.getType());
+            assertEquals(true, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+
+            item = packet.getItem("testSubscription", 11);
+            assertEquals("to", item.getValue());
+            assertEquals(PrivacyItem.Type.subscription, item.getType());
+            assertEquals(true, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+            
+            item = packet.getItem("testSubscription", 12);
+            assertEquals("from", item.getValue());
+            assertEquals(PrivacyItem.Type.subscription, item.getType());
+            assertEquals(true, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+            
+            item = packet.getItem("testSubscription", 5);
+            assertEquals("none", item.getValue());
+            assertEquals(PrivacyItem.Type.subscription, item.getType());
+            assertEquals(false, item.isAllow());
+            assertEquals(true, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(false, item.isFilterEverything());
+            
+            item = packet.getItem("testSubscription", 15);
+            assertEquals(null, item.getValue());
+            assertEquals(null, item.getType());
+            assertEquals(false, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+
+            // TEST THE testJID LIST
+            
+            item = packet.getItem("testJID", 6);
+            assertEquals("juliet@example.com", item.getValue());
+            assertEquals(PrivacyItem.Type.jid, item.getType());
+            assertEquals(true, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+            
+            item = packet.getItem("testJID", 7);
+            assertEquals("benvolio@example.org/palm", item.getValue());
+            assertEquals(PrivacyItem.Type.jid, item.getType());
+            assertEquals(false, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+            
+            item = packet.getItem("testJID", 42);
+            assertEquals(null, item.getValue());
+            assertEquals(PrivacyItem.Type.jid, item.getType());
+            assertEquals(true, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+            
+            item = packet.getItem("testJID", 666);
+            assertEquals(null, item.getValue());
+            assertEquals(null, item.getType());
+            assertEquals(false, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+            
+            // TEST THE testGroup LIST
+            
+            item = packet.getItem("testGroup", 4);
+            assertEquals("Enemies", item.getValue());
+            assertEquals(PrivacyItem.Type.group, item.getType());
+            assertEquals(false, item.isAllow());
+            assertEquals(true, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(false, item.isFilterEverything());
+            
+            item = packet.getItem("testGroup", 666);
+            assertEquals(null, item.getValue());
+            assertEquals(null, item.getType());
+            assertEquals(false, item.isAllow());
+            assertEquals(false, item.isFilterMessage());
+            assertEquals(false, item.isFilterIQ());
+            assertEquals(false, item.isFilterPresence_in());
+            assertEquals(false, item.isFilterPresence_out());
+            assertEquals(true, item.isFilterEverything());
+
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+    
+    
+    /**
+     * Check the parser with an xml with empty lists. It includes the active, 
+     * default and special list.
+     * To create the xml string based from an xml file, replace:\n with:	"\n  + "
+     */
+    public void testEmptyLists() {
+        // Make the XML to test
+    	String xml = ""
+    		  + "  <iq type='result' id='getlist1' to='romeo@example.net/orchard'>	"
+    		  + "  <query xmlns='jabber:iq:privacy'>	"
+    		  + "    <active/>	"
+    		  + "    <default name='public'/>	"
+    		  + "    <list name='public'/>	"
+    		  + "    <list name='private'/>	"
+    		  + "    <list name='special'/>	"
+    		  + "  </query>	"
+    		  + " </iq>	";
+
+        try {
+        	// Create the xml parser
+        	XmlPullParser parser = getParserFromXML(xml);
+        	// Create a packet from the xml
+        	Privacy packet = (Privacy) (new PrivacyProvider()).parseIQ(parser);
+        	
+            assertNotNull(packet);
+            assertNotNull(packet.getChildElementXML());
+            
+            assertEquals("public", packet.getDefaultName());
+            assertEquals(null, packet.getActiveName());
+            
+            assertEquals(0, packet.getPrivacyList("public").size());
+            assertEquals(0, packet.getPrivacyList("private").size());
+            assertEquals(0, packet.getPrivacyList("special").size());
+
+            assertEquals(true, packet.isDeclineActiveList());
+            assertEquals(false, packet.isDeclineDefaultList());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+ 
+    /**
+     * Check the parser with an xml with empty lists. It includes the active, 
+     * default and special list.
+     * To create the xml string based from an xml file, replace:\n with:	"\n  + "
+     */
+    public void testDeclineLists() {
+        // Make the XML to test
+    	String xml = ""
+    		  + "  <iq type='result' id='getlist1' to='romeo@example.net/orchard'>	"
+    		  + "  <query xmlns='jabber:iq:privacy'>	"
+    		  + "    <active/>	"
+    		  + "    <default/>	"
+    		  + "  </query>	"
+    		  + " </iq>	";
+
+        try {
+        	// Create the xml parser
+        	XmlPullParser parser = getParserFromXML(xml);
+        	// Create a packet from the xml
+        	Privacy packet = (Privacy) (new PrivacyProvider()).parseIQ(parser);
+        	
+            assertNotNull(packet);
+            
+            assertEquals(null, packet.getDefaultName());
+            assertEquals(null, packet.getActiveName());
+            
+            assertEquals(true, packet.isDeclineActiveList());
+            assertEquals(true, packet.isDeclineDefaultList());
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+    
+    private XmlPullParser getParserFromXML(String xml) throws XmlPullParserException {
+    	XmlPullParser parser = XmlPullParserFactory.newInstance().newPullParser();
+    	parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
+    	parser.setInput(new StringReader(xml));
+    	return parser;
+    }
+    
+    protected int getMaxConnections() {
+        return 0;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/packet/PrivacyTest.java

@@ -0,0 +1,521 @@
+/**
+ *
+ * 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.smack.packet;
+
+import org.jivesoftware.smack.PrivacyList;
+import org.jivesoftware.smack.PrivacyListListener;
+import org.jivesoftware.smack.PrivacyListManager;
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.packet.PrivacyItem.PrivacyRule;
+import org.jivesoftware.smack.test.SmackTestCase;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class PrivacyTest extends SmackTestCase {
+
+    public PrivacyTest(String arg0) {
+        super(arg0);
+    }
+   
+    
+    /**
+     * Check when a client set a new active list.
+     */
+    public void testCreateActiveList() {
+        try {
+            String listName = "testCreateActiveList";
+            
+            PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0));
+            PrivacyClient client = new PrivacyClient(privacyManager);
+            privacyManager.addListener(client);
+            
+            // Add the list that will be set as the active
+            ArrayList<PrivacyItem> items = new ArrayList<PrivacyItem>();
+            PrivacyItem item = new PrivacyItem(PrivacyItem.Type.jid.name(), true, 1);
+            item.setValue(getConnection(0).getUser());
+            items.add(item);
+            privacyManager.createPrivacyList(listName, items);
+            
+            Thread.sleep(500);
+            
+            // Set the active list
+            privacyManager.setActiveListName(listName);
+            
+            Thread.sleep(500);
+                        
+            // Assert the list composition.
+            assertEquals(listName, privacyManager.getActiveList().toString());
+            List<PrivacyItem> privacyItems = privacyManager.getPrivacyList(listName).getItems();
+            assertEquals(1, privacyItems.size());
+
+            // Assert the privacy item composition
+            PrivacyItem receivedItem = privacyItems.get(0);
+            assertEquals(1, receivedItem.getOrder());
+            assertEquals(PrivacyItem.Type.jid, receivedItem.getType());
+            assertEquals(true, receivedItem.isAllow());
+            
+            privacyManager.deletePrivacyList(listName);
+            } catch (Exception e) {
+                e.printStackTrace();
+                fail(e.getMessage());
+            }
+    }
+
+    /**
+     * Check when a client set more than one list.
+     */
+    public void testCreateTwoLists() {
+        try {
+            String listName1 = "1testCreateTwoLists";
+            String listName2 = "2testCreateTwoLists";
+            String groupName = "testCreateTwoListsGroup";
+            
+            PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0));
+            PrivacyClient client = new PrivacyClient(privacyManager);
+            privacyManager.addListener(client);
+            
+            // Add a list
+            ArrayList<PrivacyItem> items = new ArrayList<PrivacyItem>();
+            PrivacyItem item = new PrivacyItem(PrivacyItem.Type.jid.name(), true, 1);
+            item.setValue(getConnection(0).getUser());
+            items.add(item);
+            privacyManager.createPrivacyList(listName1, items);
+            
+            Thread.sleep(500);
+            
+            // Add the another list
+            ArrayList<PrivacyItem> itemsList2 = new ArrayList<PrivacyItem>();
+            item = new PrivacyItem(PrivacyItem.Type.group.name(), false, 2);
+            item.setValue(groupName);
+            item.setFilterMessage(true);
+            itemsList2.add(item);
+            privacyManager.createPrivacyList(listName2, itemsList2);
+            
+            Thread.sleep(500);
+                        
+            // Assert the list composition.
+            PrivacyList[] privacyLists = privacyManager.getPrivacyLists();
+            PrivacyList receivedList1 = null;
+            PrivacyList receivedList2 = null;
+            for (PrivacyList privacyList : privacyLists) {
+                if (listName1.equals(privacyList.toString())) {
+                    receivedList1 = privacyList;
+                }
+                if (listName2.equals(privacyList.toString())) {
+                    receivedList2 = privacyList;
+                }
+            }
+            
+            
+            PrivacyItem receivedItem;
+            // Assert on the list 1
+            assertNotNull(receivedList1);
+            assertEquals(1, receivedList1.getItems().size());
+            receivedItem = receivedList1.getItems().get(0);
+            assertEquals(1, receivedItem.getOrder());
+            assertEquals(PrivacyItem.Type.jid, receivedItem.getType());
+            assertEquals(true, receivedItem.isAllow());
+            assertEquals(getConnection(0).getUser(), receivedItem.getValue());
+            
+            // Assert on the list 2
+            assertNotNull(receivedList2);
+            assertEquals(1, receivedList2.getItems().size());
+            receivedItem = receivedList2.getItems().get(0);
+            assertEquals(2, receivedItem.getOrder());
+            assertEquals(PrivacyItem.Type.group, receivedItem.getType());
+            assertEquals(groupName, receivedItem.getValue());
+            assertEquals(false, receivedItem.isAllow());
+            assertEquals(groupName, receivedItem.getValue());
+            assertEquals(false, receivedItem.isFilterEverything());
+            assertEquals(true, receivedItem.isFilterMessage());
+            assertEquals(false, receivedItem.isFilterPresence_in());
+            assertEquals(false, receivedItem.isFilterPresence_out());
+            
+            privacyManager.deletePrivacyList(listName1);
+            privacyManager.deletePrivacyList(listName2);
+            } catch (Exception e) {
+                e.printStackTrace();
+                fail(e.getMessage());
+            }
+    }
+    
+    /**
+     * Check when a client set a new list and then update its content.
+     */
+    public void testCreateAndUpdateList() {
+        try {
+            String listName = "testCreateAndUpdateList";
+            String user = "tybalt@example.com";
+            
+            PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0));
+            PrivacyClient client = new PrivacyClient(privacyManager);
+            privacyManager.addListener(client);
+            
+            // Add the list that will be set as the active
+            ArrayList<PrivacyItem> items = new ArrayList<PrivacyItem>();
+            PrivacyItem item = new PrivacyItem(PrivacyItem.Type.jid.name(), true, 1);
+            item.setValue(getConnection(0).getUser());
+            items.add(item);
+            privacyManager.createPrivacyList(listName, items);
+            
+            Thread.sleep(500);
+            
+            // Remove the existing item and add a new one.
+            items.remove(item);
+            item = new PrivacyItem(PrivacyItem.Type.jid.name(), false, 2);
+            item.setValue(user);
+            item.setFilterPresence_out(true);
+            item.setFilterPresence_in(true);
+            item.setFilterMessage(true);
+            items.add(item);
+            
+            // Update the list on server
+            privacyManager.updatePrivacyList(listName, items);
+            
+            Thread.sleep(500);
+                        
+            // Assert the list composition.
+            PrivacyList list = privacyManager.getPrivacyList(listName);
+            assertEquals(1, list.getItems().size());
+
+            // Assert the privacy item composition
+            PrivacyItem receivedItem = list.getItems().get(0);
+            assertEquals(2, receivedItem.getOrder());
+            assertEquals(PrivacyItem.Type.jid, receivedItem.getType());
+            assertEquals(false, receivedItem.isAllow());
+            assertEquals(user, receivedItem.getValue());
+            assertEquals(false, receivedItem.isFilterEverything());
+            assertEquals(true, receivedItem.isFilterMessage());
+            assertEquals(true, receivedItem.isFilterPresence_in());
+            assertEquals(true, receivedItem.isFilterPresence_out());
+            assertEquals(true, client.wasModified());
+
+            privacyManager.deletePrivacyList(listName);
+            } catch (Exception e) {
+                e.printStackTrace();
+                fail(e.getMessage());
+            }
+    }
+    
+    /**
+     * Check when a client denies the use of a default list.
+     */
+    public void testDenyDefaultList() {
+    	try {
+    		PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0));
+    		PrivacyClient client = new PrivacyClient(privacyManager);
+    		privacyManager.addListener(client);
+    		
+    		privacyManager.declineDefaultList();
+    		
+    		Thread.sleep(500);
+     	
+            try {
+                // The list should not exist and an error will be raised
+                privacyManager.getDefaultList();
+            } catch (XMPPException xmppException) {
+                assertEquals(404, xmppException.getXMPPError().getCode());
+            }
+            
+	    	assertEquals(null, null);
+	        } catch (Exception e) {
+	            e.printStackTrace();
+	            fail(e.getMessage());
+	        }
+    }
+
+    /**
+     * Check when a client denies the use of the active list.
+     */
+    public void testDenyActiveList() {
+        try {
+            PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0));
+            PrivacyClient client = new PrivacyClient(privacyManager);
+            privacyManager.addListener(client);
+            
+            privacyManager.declineActiveList();
+            
+            Thread.sleep(500);
+        
+            try {
+                // The list should not exist and an error will be raised
+                privacyManager.getActiveList();
+            } catch (XMPPException xmppException) {
+                assertEquals(404, xmppException.getXMPPError().getCode());
+            }
+            
+            assertEquals(null, null);
+            } catch (Exception e) {
+                e.printStackTrace();
+                fail(e.getMessage());
+            }
+    }
+    
+    /**
+     * Check when a client set a new default list.
+     */
+    public void testCreateDefaultList() {
+    	try {
+    		String listName = "testCreateDefaultList";
+    		
+    		PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0));
+    		PrivacyClient client = new PrivacyClient(privacyManager);
+    		privacyManager.addListener(client);
+    		
+    		// Add the list that will be set as the Default
+    		ArrayList<PrivacyItem> items = new ArrayList<PrivacyItem>();
+    		PrivacyItem item = new PrivacyItem(PrivacyItem.Type.jid.name(), true, 1);
+        	item.setValue(getConnection(0).getUser());
+    		items.add(item);
+    		privacyManager.createPrivacyList(listName, items);
+    		
+    		Thread.sleep(500);
+    		
+    		// Set the Default list
+    		privacyManager.setDefaultListName(listName);
+	    	
+	    	Thread.sleep(500);
+	    		    	
+	    	// Assert the list composition.
+	    	assertEquals(listName, privacyManager.getDefaultList().toString());
+	    	List<PrivacyItem> privacyItems = privacyManager.getPrivacyList(listName).getItems();
+	    	assertEquals(1, privacyItems.size());
+
+	    	// Assert the privacy item composition
+	    	PrivacyItem receivedItem = privacyItems.get(0);
+	    	assertEquals(1, receivedItem.getOrder());
+	    	assertEquals(PrivacyItem.Type.jid, receivedItem.getType());
+	    	assertEquals(true, receivedItem.isAllow());
+            
+            privacyManager.deletePrivacyList(listName);
+	        } catch (Exception e) {
+	            e.printStackTrace();
+	            fail(e.getMessage());
+	        }
+    }
+
+    /**
+     * Check when a client add a new list and then remove it.
+     */
+    public void testRemoveList() {
+    	try {
+    		String listName = "testRemoveList";
+    		
+    		PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0));
+    		PrivacyClient client = new PrivacyClient(privacyManager);
+    		privacyManager.addListener(client);
+    		
+    		// Add the list that will be set as the Default
+    		ArrayList<PrivacyItem> items = new ArrayList<PrivacyItem>();
+    		PrivacyItem item = new PrivacyItem(PrivacyItem.Type.jid.name(), true, 1);
+        	item.setValue(getConnection(0).getUser());
+    		items.add(item);
+    		privacyManager.createPrivacyList(listName, items);
+    		
+    		Thread.sleep(500);
+    		
+    		// Set the Default list
+    		privacyManager.setDefaultListName(listName);
+	    	
+	    	Thread.sleep(500);
+
+	    	privacyManager.deletePrivacyList(listName);
+	    	
+	    	Thread.sleep(500);
+
+            try {
+                // The list should not exist and an error will be raised
+                privacyManager.getPrivacyList(listName);
+            } catch (XMPPException xmppException) {
+                assertEquals(404, xmppException.getXMPPError().getCode());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * Check different types of privacy items.
+     */
+    public void testPrivacyItems() {
+    	try {
+    		String listName = "testPrivacyItems";
+    		String user = "tybalt@example.com";
+    		String groupName = "enemies";
+    		
+    		PrivacyListManager privacyManager = PrivacyListManager.getInstanceFor(getConnection(0));
+    		PrivacyClient client = new PrivacyClient(privacyManager);
+    		privacyManager.addListener(client);
+    		
+    		PrivacyItem[] originalPrivacyItems = new PrivacyItem[12];
+    		int i=0;
+    		
+    		// Items to test JID
+    		PrivacyItem item = new PrivacyItem(PrivacyItem.Type.jid.name(), true, i);
+        	item.setValue(i + "_" + user);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+
+    		item = new PrivacyItem(PrivacyItem.Type.jid.name(), false, i);
+        	item.setValue(i + "_" + user);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+
+        	// Items to test suscription
+    		item = new PrivacyItem(PrivacyItem.Type.subscription.name(), true, i);
+        	item.setValue(PrivacyRule.SUBSCRIPTION_BOTH);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+
+    		item = new PrivacyItem(PrivacyItem.Type.subscription.name(), false, i);
+        	item.setValue(PrivacyRule.SUBSCRIPTION_FROM);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+
+    		item = new PrivacyItem(PrivacyItem.Type.subscription.name(), true, i);
+        	item.setValue(PrivacyRule.SUBSCRIPTION_TO);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+
+    		item = new PrivacyItem(PrivacyItem.Type.subscription.name(), false, i);
+        	item.setValue(PrivacyRule.SUBSCRIPTION_NONE);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+        	
+        	// Items to test Group
+        	item = new PrivacyItem(PrivacyItem.Type.group.name(), false, i);
+        	item.setValue(groupName);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+        	
+        	// Items to test messages
+        	item = new PrivacyItem(PrivacyItem.Type.group.name(), false, i);
+        	item.setValue(groupName);
+        	item.setFilterMessage(true);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+        	
+        	// Items to test presence notifications
+        	item = new PrivacyItem(PrivacyItem.Type.group.name(), false, i);
+        	item.setValue(groupName);
+        	item.setFilterMessage(true);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+        	
+        	item = new PrivacyItem(null, false, i);
+        	item.setFilterPresence_in(true);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+        	
+    		item = new PrivacyItem(PrivacyItem.Type.subscription.name(), false, i);
+        	item.setValue(PrivacyRule.SUBSCRIPTION_TO);
+        	item.setFilterPresence_out(true);
+        	originalPrivacyItems[i] = item;
+        	i = i + 1;
+        	
+        	item = new PrivacyItem(PrivacyItem.Type.jid.name(), false, i);
+        	item.setValue(i + "_" + user);
+        	item.setFilterPresence_out(true);
+        	item.setFilterPresence_in(true);
+        	item.setFilterMessage(true);
+        	originalPrivacyItems[i] = item;
+
+        	// Set the new privacy list
+    		privacyManager.createPrivacyList(listName, Arrays.asList(originalPrivacyItems));
+
+    		Thread.sleep(500);
+
+	    	// Assert the server list composition.
+	    	List<PrivacyItem> privacyItems = privacyManager.getPrivacyList(listName).getItems();
+	    	assertEquals(originalPrivacyItems.length, privacyItems.size());
+
+	    	// Assert the local and server privacy item composition
+	    	PrivacyItem originalItem;
+	    	PrivacyItem receivedItem;
+	    	int index;
+	    	for (int j = 0; j < originalPrivacyItems.length; j++) {
+	    		// Look for the same server and original items
+	    		receivedItem = privacyItems.get(j);
+	    		index = 0;
+	    		while ((index < originalPrivacyItems.length) 
+	    				&& (originalPrivacyItems[index].getOrder() != receivedItem.getOrder())) {
+	    			index++;
+				}
+	    		originalItem = originalPrivacyItems[index];
+	    		
+	    		// Assert the items
+	    		assertEquals(originalItem.getOrder(), receivedItem.getOrder());
+		    	assertEquals(originalItem.getType(), receivedItem.getType());
+		    	assertEquals(originalItem.isAllow(), receivedItem.isAllow());
+		    	assertEquals(originalItem.getValue(), receivedItem.getValue());
+		    	assertEquals(originalItem.isFilterEverything(), receivedItem.isFilterEverything());
+		    	assertEquals(originalItem.isFilterIQ(), receivedItem.isFilterIQ());
+		    	assertEquals(originalItem.isFilterMessage(), receivedItem.isFilterMessage());
+		    	assertEquals(originalItem.isFilterPresence_in(), receivedItem.isFilterPresence_in());
+		    	assertEquals(originalItem.isFilterPresence_out(), receivedItem.isFilterPresence_out());
+		    	}
+            
+            privacyManager.deletePrivacyList(listName);
+	        } catch (Exception e) {
+	            e.printStackTrace();
+	            fail(e.getMessage());
+	        }
+    }
+    
+	protected int getMaxConnections() {
+		return 1;
+	}
+
+    /**
+     * This class supports automated tests about privacy communication from the
+     * server to the client.
+     * 
+     * @author Francisco Vives
+     */
+
+    public class PrivacyClient implements PrivacyListListener {
+        /**
+         * holds if the receiver list was modified
+         */
+        private boolean wasModified = false;
+
+        /**
+         * holds a privacy to hold server requests Clients should not use Privacy
+         * class since it is private for the smack framework.
+         */
+        private Privacy privacy = new Privacy();
+
+        public PrivacyClient(PrivacyListManager manager) {
+            super();
+        }
+
+        public void setPrivacyList(String listName, List<PrivacyItem> listItem) {
+            privacy.setPrivacyList(listName, listItem);
+        }
+
+        public void updatedPrivacyList(String listName) {
+            this.wasModified = true;
+        }
+
+        public boolean wasModified() {
+            return this.wasModified;
+        }
+    }
+}
+
+

smack-core/src/integration-test/java/org/jivesoftware/smack/test/SmackTestCase.java

@@ -0,0 +1,535 @@
+/**
+ *
+ * Copyright 2003-2005 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.smack.test;
+
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.net.SocketFactory;
+
+import junit.framework.TestCase;
+
+import org.jivesoftware.smack.ConnectionConfiguration;
+import org.jivesoftware.smack.TCPConnection;
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.util.ConnectionUtils;
+import org.xmlpull.v1.XmlPullParserFactory;
+import org.xmlpull.v1.XmlPullParser;
+
+/**
+ * Base class for all the test cases which provides a pre-configured execution context. This 
+ * means that any test case that subclassifies this base class will have access to a pool of 
+ * connections and to the user of each connection. The maximum number of connections in the pool
+ * can be controlled by the message {@link #getMaxConnections()} which every subclass must 
+ * implement.<p>   
+ * 
+ * This base class defines a default execution context (i.e. host, port, chat domain and muc 
+ * domain) which can be found in the file "config/test-case.xml". However, each subclass could
+ * redefine the default configuration by providing its own configuration file (if desired). The
+ * name of the configuration file must be of the form <test class name>.xml (e.g. RosterTest.xml).
+ * The file must be placed in the folder "config". This folder is where the default configuration 
+ * file is being held.
+ *
+ * @author Gaston Dombiak
+ */
+public abstract class SmackTestCase extends TestCase {
+
+    private String host = "localhost";
+    private String serviceName = "localhost";
+    private int port = 5222;
+    private String usernamePrefix = "user";
+    private String passwordPrefix;
+    private boolean testAnonymousLogin = false;
+    private Map<String, String> accountCreationParameters = new HashMap<String, String>();
+    private boolean samePassword;
+    private List<Integer> createdUserIdx = new ArrayList<Integer>();
+    private boolean compressionEnabled = false;
+
+    private String[] usernames;
+    private String[] passwords;
+    
+    private String chatDomain = "chat";
+    private String mucDomain = "conference";
+
+    private XMPPTCPConnection[] connections = null;
+
+    /**
+     * Constructor for SmackTestCase.
+     * @param arg0 arg for SmackTestCase
+     */
+    public SmackTestCase(String arg0) {
+        super(arg0);
+    }
+
+    /**
+     * Returns the maximum number of connections to initialize for this test case. All the 
+     * initialized connections will be connected to the server using a new test account for 
+     * each conection. 
+     * 
+     * @return the maximum number of connections to initialize for this test case.
+     */
+    protected abstract int getMaxConnections();
+
+    /**
+     * Returns a SocketFactory that will be used to create the socket to the XMPP server. By 
+     * default no SocketFactory is used but subclasses my want to redefine this method.<p>
+     * 
+     * A custom SocketFactory allows fine-grained control of the actual connection to the XMPP 
+     * server. A typical use for a custom SocketFactory is when connecting through a SOCKS proxy.
+     * 
+     * @return a SocketFactory that will be used to create the socket to the XMPP server.
+     */
+    protected SocketFactory getSocketFactory() {
+        return null;
+    }
+
+    /**
+     * Returns <code>false</code> if the connections initialized by the test case will be
+     * automatically connected to the XMPP server.
+     * Returns <code>true</code> if the connections initialized by the test case will
+     * NOT be connected to the XMPP server. To connect the connections invoke
+     * {@link #connectAndLogin(int)}.
+     * <p>
+     * Connections are connected by default.
+     * Overwrite this method if the test case needs unconnected connections.
+     * 
+     * @return <code>true</code> if connections should NOT be connected automatically,
+     *         <code>false</code> if connections should be connected automatically.
+     */
+    protected boolean createOfflineConnections() {
+        return false;
+    }
+    
+    /**
+     * Returns the XMPPTCPConnection located at the requested position. Each test case holds a
+     * pool of connections which is initialized while setting up the test case. The maximum
+     * number of connections is controlled by the message {@link #getMaxConnections()} which
+     * every subclass must implement.<p>   
+     * 
+     * If the requested position is greater than the connections size then an 
+     * IllegalArgumentException will be thrown. 
+     * 
+     * @param index the position in the pool of the connection to look for.
+     * @return the XMPPTCPConnection located at the requested position.
+     */
+    protected XMPPTCPConnection getConnection(int index) {
+        if (index > getMaxConnections()) {
+            throw new IllegalArgumentException("Index out of bounds");
+        }
+        return connections[index];
+    }
+
+    /**
+     * Creates a new XMPPTCPConnection using the connection preferences. This is useful when
+     * not using a connection from the connection pool in a test case.
+     *
+     * @return a new XMPP connection.
+     */
+    protected XMPPTCPConnection createConnection() {
+        // Create the configuration for this new connection
+        ConnectionConfiguration config = new ConnectionConfiguration(host, port);
+        config.setCompressionEnabled(compressionEnabled);
+        config.setSendPresence(sendInitialPresence());
+        if (getSocketFactory() == null) {
+            config.setSocketFactory(getSocketFactory());
+        }
+        return new XMPPTCPConnection(config);
+    }
+
+    /**
+     * Returns the name of the user (e.g. johndoe) that is using the connection 
+     * located at the requested position.
+     * 
+     * @param index the position in the pool of the connection to look for.
+     * @return the user of the user (e.g. johndoe).
+     */
+    protected String getUsername(int index) {
+        return usernames[index];
+    }
+    
+    /**
+     * Returns the password of the user (e.g. johndoe) that is using the connection 
+     * located at the requested position.
+     * 
+     * @param index the position in the pool of the connection to look for.
+     * @return the password of the user (e.g. johndoe).
+     */
+    protected String getPassword(int index) {
+        return passwords[index];
+    }
+
+    /**
+     * Returns the bare XMPP address of the user (e.g. johndoe@jabber.org) that is
+     * using the connection located at the requested position.
+     * 
+     * @param index the position in the pool of the connection to look for.
+     * @return the bare XMPP address of the user (e.g. johndoe@jabber.org).
+     */
+    protected String getBareJID(int index) {
+        return getUsername(index) + "@" + getConnection(index).getServiceName();
+    }
+
+    /**
+     * Returns the full XMPP address of the user (e.g. johndoe@jabber.org/Smack) that is
+     * using the connection located at the requested position.
+     * 
+     * @param index the position in the pool of the connection to look for.
+     * @return the full XMPP address of the user (e.g. johndoe@jabber.org/Smack).
+     */
+    protected String getFullJID(int index) {
+        return getBareJID(index) + "/Smack";
+    }
+
+    protected String getHost() {
+        return host;
+    }
+
+    protected int getPort() {
+        return port;
+    }
+
+    protected String getServiceName() {
+        return serviceName;
+    }
+
+    /**
+     * Returns the default groupchat service domain.
+     * 
+     * @return the default groupchat service domain.
+     */
+    protected String getChatDomain() {
+        return chatDomain;
+    }
+
+    /**
+     * Returns the default MUC service domain.
+     * 
+     * @return the default MUC service domain.
+     */
+    protected String getMUCDomain() {
+        return mucDomain + "." + serviceName;
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        init();
+        if (getMaxConnections() < 1) {
+            return;
+        }
+        connections = new XMPPTCPConnection[getMaxConnections()];
+        usernames = new String[getMaxConnections()];
+        passwords = new String[getMaxConnections()];
+        
+        try {
+            // Connect to the server
+            for (int i = 0; i < getMaxConnections(); i++) {
+                connections[i] = createConnection();
+                if (!createOfflineConnections())
+                    connections[i].connect();
+
+                String currentPassword = usernamePrefix + (i+1);
+                String currentUser = currentPassword;
+
+                if (passwordPrefix != null)
+                    currentPassword = (samePassword ? passwordPrefix : passwordPrefix + (i+1));
+
+                usernames[i] = currentUser;
+                passwords[i] = currentPassword;
+            }
+            // Use the host name that the server reports. This is a good idea in most
+            // cases, but could fail if the user set a hostname in their XMPP server
+            // that will not resolve as a network connection.
+            host = connections[0].getHost();
+            serviceName = connections[0].getServiceName();
+            
+            if (!createOfflineConnections()) {
+                for (int i = 0; i < getMaxConnections(); i++) {
+                    String currentUser = usernames[i];
+                    String currentPassword = passwords[i];
+                    
+                    try {
+                        getConnection(i).login(currentUser, currentPassword, "Smack");
+                    } catch (XMPPException e) {
+                        // Create the test accounts
+                        if (!getConnection(0).getAccountManager().supportsAccountCreation())
+                            fail("Server does not support account creation");
+                        
+                        // Create the account and try logging in again as the 
+                        // same user.
+                        try {
+                            createAccount(i, currentUser, currentPassword);
+                        } catch (Exception e1) {
+                            e1.printStackTrace();
+                            fail("Could not create user: " + currentUser);
+                        }
+                        i--;
+                    }
+                }
+                // Let the server process the available presences
+                Thread.sleep(150);
+            }
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+
+    protected void connectAndLogin(int connectionIndex) throws XMPPException
+    {
+    	String password = usernamePrefix + (connectionIndex + 1);
+    	
+    	if (passwordPrefix != null)
+    		password = (samePassword ? passwordPrefix : passwordPrefix + (connectionIndex + 1));
+
+    	TCPConnection con = getConnection(connectionIndex);
+    	
+    	if (!con.isConnected())
+    		con.connect();
+    	try {
+    	    con.login(usernamePrefix + (connectionIndex + 1), password, "Smack");
+    	} catch (XMPPException e) {
+    	    createAccount(connectionIndex, usernamePrefix + (connectionIndex + 1), password);
+            con.login(usernamePrefix + (connectionIndex + 1), password, "Smack");
+    	}
+    }
+
+    protected void disconnect(int connectionIndex) throws XMPPException
+    {
+    	getConnection(connectionIndex).disconnect();
+    }
+
+    private void createAccount(int connectionIdx, String username, String password)
+	{
+        // Create the test account
+        try {
+            getConnection(connectionIdx).getAccountManager().createAccount(username, password);
+            createdUserIdx.add(connectionIdx);
+        } catch (XMPPException e) {
+        	e.printStackTrace();
+        	fail(e.getMessage());
+        }
+	}
+
+	protected void tearDown() throws Exception {
+        super.tearDown();
+
+        for (int i = 0; i < getMaxConnections(); i++)
+		{
+        	if (createdUserIdx.contains(i))
+        	{
+                try {
+                    // If not connected, connect so that we can delete the account.
+                    if (!getConnection(i).isConnected()) {
+                        XMPPTCPConnection con = getConnection(i);
+                        con.connect();
+                        con.login(getUsername(i), getUsername(i));
+                    }
+                    else if (!getConnection(i).isAuthenticated()) {
+                        getConnection(i).login(getUsername(i), getUsername(i));     
+                    }
+                    // Delete the created account for the test
+                    getConnection(i).getAccountManager().deleteAccount();
+                }
+                catch (Exception e) {
+                    e.printStackTrace();
+                }
+        	}
+            if (getConnection(i).isConnected()) {
+                // Close the connection
+                getConnection(i).disconnect();
+            }
+        }
+    }
+
+    protected boolean sendInitialPresence() {
+        return true;
+    }
+
+    /**
+     * Initializes the context of the test case. We will first try to load the configuration from 
+     * a file whose name is conformed by the test case class name plus an .xml extension 
+     * (e.g RosterTest.xml). If no file was found under that name then we will try to load the 
+     * default configuration for all the test cases from the file "config/test-case.xml".
+     *
+     */
+    private void init() {
+        try {
+            boolean found = false;
+            // Try to load the configutation from an XML file specific for this test case 
+            Enumeration<URL> resources =
+                ClassLoader.getSystemClassLoader().getResources(getConfigurationFilename());
+            while (resources.hasMoreElements()) {
+                found = parseURL(resources.nextElement());
+            }
+            // If none was found then try to load the configuration from the default configuration 
+            // file (i.e. "config/test-case.xml")
+            if (!found) {
+                resources = ClassLoader.getSystemClassLoader().getResources("config/test-case.xml");
+                while (resources.hasMoreElements()) {
+                    found = parseURL(resources.nextElement());
+                }
+            }
+            if (!found) {
+                System.err.println("File config/test-case.xml not found. Using default config.");
+            }
+        }
+        catch (Exception e) {
+            /* Do Nothing */
+        }
+    }
+
+    /**
+     * Returns true if the given URL was found and parsed without problems. The file provided
+     * by the URL must contain information useful for the test case configuration, such us,
+     * host and port of the server.  
+     * 
+     * @param url the url of the file to parse.
+     * @return true if the given URL was found and parsed without problems.
+     */
+    private boolean parseURL(URL url) {
+        boolean parsedOK = false;
+        InputStream systemStream = null;
+        try {
+            systemStream = url.openStream();
+            XmlPullParser parser = XmlPullParserFactory.newInstance().newPullParser();
+            parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
+            parser.setInput(systemStream, "UTF-8");
+            int eventType = parser.getEventType();
+            do {
+                if (eventType == XmlPullParser.START_TAG) {
+                    if (parser.getName().equals("host")) {
+                        host = parser.nextText();
+                    }
+                    else if (parser.getName().equals("port")) {
+                        port = parseIntProperty(parser, port);
+                    }
+                    else if (parser.getName().equals("serviceName")) {
+                        serviceName = parser.nextText();
+                    }
+                    else if (parser.getName().equals("chat")) {
+                        chatDomain = parser.nextText();
+                    }
+                    else if (parser.getName().equals("muc")) {
+                        mucDomain = parser.nextText();
+                    }
+                    else if (parser.getName().equals("username")) {
+                        usernamePrefix = parser.nextText();
+                    }
+                    else if (parser.getName().equals("password")) {
+                        samePassword = "true".equals(parser.getAttributeValue(0));
+                        passwordPrefix = parser.nextText();
+                    }
+                    else if (parser.getName().equals("testAnonymousLogin")) {
+                        testAnonymousLogin = "true".equals(parser.nextText());
+                    }
+                    else if (parser.getName().equals("accountCreationParameters")) {
+                        int numAttributes = parser.getAttributeCount();
+                        String key = null;
+                        String value = null;
+
+                        for (int i = 0; i < numAttributes; i++) {
+                            key = parser.getAttributeName(i);
+                            value = parser.getAttributeValue(i);
+                            accountCreationParameters.put(key, value);
+                        }
+                    }
+                    else if (parser.getName().equals("compressionEnabled")) {
+                        compressionEnabled = "true".equals(parser.nextText());
+                    }
+                }
+                eventType = parser.next();
+            }
+            while (eventType != XmlPullParser.END_DOCUMENT);
+            parsedOK = true;
+        }
+        catch (Exception e) {
+            e.printStackTrace();
+        }
+        finally {
+            try {
+                systemStream.close();
+            }
+            catch (Exception e) {
+                /* Do Nothing */
+            }
+        }
+        return parsedOK;
+    }
+
+    private static int parseIntProperty(XmlPullParser parser, int defaultValue) throws Exception {
+        try {
+            return Integer.parseInt(parser.nextText());
+        }
+        catch (NumberFormatException nfe) {
+            nfe.printStackTrace();
+            return defaultValue;
+        }
+    }
+
+    /**
+     * Returns the name of the configuration file related to <b>this</b> test case. By default all 
+     * the test cases will use the same configuration file. However, it's possible to override the
+     * default configuration by providing a file of the form <test case class name>.xml
+     * (e.g. RosterTest.xml).
+     * 
+     * @return the name of the configuration file related to this test case.
+     */
+    private String getConfigurationFilename() {
+        String fullClassName = this.getClass().getName();
+        int firstChar = fullClassName.lastIndexOf('.') + 1;
+        return "config/" + fullClassName.substring(firstChar) + ".xml";
+    }
+
+    /**
+     * Subscribes all connections with each other: They all become friends
+     * 
+     * @throws XMPPException
+     */
+    protected void letsAllBeFriends() throws XMPPException {
+        ConnectionUtils.letsAllBeFriends(connections);
+    }
+
+    /**
+     * Compares two contents of two byte arrays to make sure that they are equal
+     *
+     * @param message The message to show in the case of failure
+     * @param byteArray1 The first byte array.
+     * @param byteArray2 The second byte array.
+     */
+    public static void assertEquals(String message, byte [] byteArray1, byte [] byteArray2) {
+        if(byteArray1.length != byteArray2.length) {
+            fail(message);
+        }
+        for(int i = 0; i < byteArray1.length; i++) {
+            assertEquals(message, byteArray1[i], byteArray2[i]);
+        }
+    }
+
+    public boolean isTestAnonymousLogin() {
+        return testAnonymousLogin;
+    }
+
+    public Map<String, String> getAccountCreationParameters() {
+        return accountCreationParameters;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/util/CacheTest.java

@@ -0,0 +1,43 @@
+/**
+ *
+ * Copyright 2005 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.smack.util;
+
+import junit.framework.TestCase;
+
+/**
+ * A test case for the Cache class.
+ */
+public class CacheTest extends TestCase {
+
+    public void testMaxSize() {
+        Cache<Integer, String> cache = new Cache<Integer, String>(100, -1);
+        for (int i=0; i < 1000; i++) {
+            cache.put(i, "value");
+            assertTrue("Cache size must never be larger than 100.", cache.size() <= 100);
+        }
+    }
+
+    public void testLRU() {
+        Cache<Integer, String> cache = new Cache<Integer, String>(100, -1);
+        for (int i=0; i < 1000; i++) {
+            cache.put(i, "value");
+            assertTrue("LRU algorithm for cache key of '0' failed.",
+                    cache.get(new Integer(0)) != null);
+        }
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/util/ConnectionUtils.java

@@ -0,0 +1,29 @@
+package org.jivesoftware.smack.util;
+
+import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.Roster;
+import org.jivesoftware.smack.XMPPException;
+
+public class ConnectionUtils {
+
+    private ConnectionUtils() {}
+    
+    public static void becomeFriends(XMPPConnection con0, XMPPConnection con1) throws XMPPException {
+        Roster r0 = con0.getRoster();
+        Roster r1 = con1.getRoster();
+        r0.setSubscriptionMode(Roster.SubscriptionMode.accept_all);
+        r1.setSubscriptionMode(Roster.SubscriptionMode.accept_all);
+        r0.createEntry(con1.getUser(), "u2", null);
+        r1.createEntry(con0.getUser(), "u1", null);
+    }
+
+    public static void letsAllBeFriends(XMPPConnection[] connections) throws XMPPException {
+        for (XMPPConnection c1 : connections) {
+            for (XMPPConnection c2 : connections) {
+                if (c1 == c2)
+                    continue;
+                becomeFriends(c1, c2);
+            }
+        }
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/util/DNSUtilTest.java

@@ -0,0 +1,147 @@
+package org.jivesoftware.smack.util;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+import org.jivesoftware.smack.util.dns.DNSJavaResolver;
+import org.jivesoftware.smack.util.dns.DNSResolver;
+import org.jivesoftware.smack.util.dns.HostAddress;
+import org.jivesoftware.smack.util.dns.JavaxResolver;
+import org.jivesoftware.smack.util.dns.SRVRecord;
+import org.junit.Test;
+
+public class DNSUtilTest {
+    private static final String igniterealtimeDomain = "igniterealtime.org";
+    private static final String igniterealtimeXMPPServer = "xmpp." + igniterealtimeDomain;
+    private static final int igniterealtimeClientPort = 5222;
+    private static final int igniterealtimeServerPort = 5269;
+
+    @Test
+    public void xmppClientDomainJavaXTest() {
+        DNSResolver resolver = JavaxResolver.getInstance();
+        assertNotNull(resolver);
+        DNSUtil.setDNSResolver(resolver);
+        xmppClientDomainTest();
+    }
+
+    @Test
+    public void xmppServerDomainJavaXTest() {
+        DNSResolver resolver = JavaxResolver.getInstance();
+        assertNotNull(resolver);
+        DNSUtil.setDNSResolver(resolver);
+        xmppServerDomainTest();
+    }
+
+    @Test
+    public void xmppClientDomainDNSJavaTest() {
+        DNSResolver resolver = DNSJavaResolver.getInstance();
+        assertNotNull(resolver);
+        DNSUtil.setDNSResolver(resolver);
+        xmppClientDomainTest();
+    }
+
+    @Test
+    public void xmppServerDomainDNSJavaTest() {
+        DNSResolver resolver = DNSJavaResolver.getInstance();
+        assertNotNull(resolver);
+        DNSUtil.setDNSResolver(resolver);
+        xmppServerDomainTest();
+    }
+
+    @Test
+    public void sortSRVlowestPrioFirstTest() {
+        List<HostAddress> sortedRecords = DNSUtil.sortSRVRecords(createSRVRecords());
+        assertTrue(sortedRecords.get(0).getFQDN().equals("0.20.foo.bar"));
+    }
+
+    @Test
+    public void sortSRVdistributeOverWeights() {
+        int weight50 = 0;
+        int weight20one = 0;
+        int weight20two = 0;
+        int weight10 = 0;
+        for (int i = 0; i < 1000; i++) {
+            List<HostAddress> sortedRecords = DNSUtil.sortSRVRecords(createSRVRecords());
+            String host = sortedRecords.get(1).getFQDN();
+            if (host.equals("5.20.one.foo.bar")) {
+                weight20one++;
+            } else if (host.equals("5.20.two.foo.bar")) {
+                weight20two++;
+            } else if (host.equals("5.10.foo.bar")) {
+                weight10++;
+            } else if (host.equals("5.50.foo.bar")) {
+                weight50++;
+            } else {
+                fail("Wrong host after SRVRecord sorting");
+            }
+        }
+        assertTrue(weight50 > 400 && weight50 < 600);
+        assertTrue(weight20one > 100 && weight20one < 300);
+        assertTrue(weight20two > 100 && weight20two < 300);
+        assertTrue(weight10 > 0&& weight10 < 200);
+    }
+
+    @Test
+    public void sortSRVdistributeZeroWeights() {
+        int weightZeroOne = 0;
+        int weightZeroTwo = 0;
+        for (int i = 0; i < 1000; i++) {
+            List<HostAddress> sortedRecords = DNSUtil.sortSRVRecords(createSRVRecords());
+            // Remove the first 5 records with a lower priority
+            for (int j = 0; j < 5; j++) {
+                sortedRecords.remove(0);
+            }
+            String host = sortedRecords.remove(0).getFQDN();
+            if (host.equals("10.0.one.foo.bar")) {
+                weightZeroOne++;
+            } else if (host.endsWith("10.0.two.foo.bar")) {
+                weightZeroTwo++;
+            } else {
+                fail("Wrong host after SRVRecord sorting");
+            }
+        }
+        assertTrue(weightZeroOne > 400 && weightZeroOne < 600);
+        assertTrue(weightZeroTwo > 400 && weightZeroTwo < 600);
+    }
+
+    private void xmppClientDomainTest() {
+        List<HostAddress> hostAddresses = DNSUtil.resolveXMPPDomain(igniterealtimeDomain);
+        HostAddress ha = hostAddresses.get(0);
+        assertEquals(ha.getFQDN(), igniterealtimeXMPPServer);
+        assertEquals(ha.getPort(), igniterealtimeClientPort);
+    }
+    
+    private void xmppServerDomainTest() {
+        List<HostAddress> hostAddresses = DNSUtil.resolveXMPPServerDomain(igniterealtimeDomain);
+        HostAddress ha = hostAddresses.get(0);
+        assertEquals(ha.getFQDN(), igniterealtimeXMPPServer);
+        assertEquals(ha.getPort(), igniterealtimeServerPort);
+    }
+    
+    private static List<SRVRecord> createSRVRecords() {
+        List<SRVRecord> records = new ArrayList<SRVRecord>();
+        // We create one record with priority 0 that should also be tried first
+        // Then 4 records with priority 5 and different weights (50, 20, 20, 10)
+        // Then 2 records with priority 10 and weight 0 which should be treaded equal
+        // These records are added in a 'random' way to the list
+        try {
+            records.add(new SRVRecord("5.20.one.foo.bar", 42, 5, 20));     // Priority 5, Weight 20
+            records.add(new SRVRecord("10.0.one.foo.bar", 42, 10, 0)); // Priority 10, Weight 0
+            records.add(new SRVRecord("5.10.foo.bar", 42, 5, 10));     // Priority 5, Weight 10
+            records.add(new SRVRecord("10.0.two.foo.bar", 42, 10, 0)); // Priority 10, Weight 0
+            records.add(new SRVRecord("5.20.two.foo.bar", 42, 5, 20));     // Priority 5, Weight 20
+            records.add(new SRVRecord("0.20.foo.bar", 42, 0, 20));     // Priority 0, Weight 20
+            records.add(new SRVRecord("5.50.foo.bar", 42, 5, 50));     // Priority 5, Weight 50
+        } catch (IllegalArgumentException e) {
+            // Ignore
+        }
+        assertTrue(records.size() > 0);
+        return records;
+    }
+}

smack-core/src/integration-test/java/org/jivesoftware/smack/util/XMPPErrorTest.java

@@ -0,0 +1,203 @@
+/**
+ *
+ * Copyright 2006 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.smack.util;
+
+import java.io.StringReader;
+
+import org.jivesoftware.smack.packet.XMPPError;
+import org.jivesoftware.smack.test.SmackTestCase;
+import org.xmlpull.v1.XmlPullParserFactory;
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+public class XMPPErrorTest extends SmackTestCase {
+
+    public XMPPErrorTest(String arg0) {
+        super(arg0);
+    }
+	
+    /**
+     * Check the creation of a new xmppError locally.
+    */
+    public void testLocalErrorCreation() {
+    	XMPPError error = new XMPPError(XMPPError.Condition.item_not_found);
+        error.toXML();
+
+    	assertEquals(error.getCondition(), "item-not-found");
+    	assertEquals(error.getCode(), 404);
+    	assertEquals(error.getType(), XMPPError.Type.CANCEL);
+    	assertNull(error.getMessage());
+    }
+ 
+    /**
+     * Check the creation of a new xmppError locally.
+    */
+    public void testLocalErrorWithCommentCreation() {
+        String message = "Error Message";
+        XMPPError error = new XMPPError(XMPPError.Condition.item_not_found, message);
+        error.toXML();
+
+        assertEquals(error.getCondition(), "item-not-found");
+        assertEquals(error.getCode(), 404);
+        assertEquals(error.getType(), XMPPError.Type.CANCEL);
+        assertEquals(error.getMessage(), message);
+    }
+    
+    /**
+     * Check the creation of a new xmppError locally where there is not a default defined.
+    */
+    public void testUserDefinedErrorWithCommentCreation() {
+        String message = "Error Message";
+        XMPPError error = new XMPPError(new XMPPError.Condition("my_own_error"), message);
+        error.toXML();
+
+        assertEquals(error.getCondition(), "my_own_error");
+        assertEquals(error.getCode(), 0);
+        assertNull(error.getType());
+        assertEquals(error.getMessage(), message);
+    }
+    
+    /**
+     * Check the parser with an xml with the 404 error.
+    */
+    public void test404() {
+        // Make the XML to test
+    	String xml = "<error code='404' type='cancel'>" +
+    			"<item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
+    			"</error></iq>";
+        try {
+        	// Create the xml parser
+        	XmlPullParser parser = getParserFromXML(xml);
+        	// Create a packet from the xml
+        	XMPPError packet = parseError(parser);
+        	
+            assertNotNull(packet);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+ 
+    /**
+     * Check the parser with an xml with the 404 error.
+    */
+    public void testCancel() {
+        // Make the XML to test
+    	String xml = "<error type='cancel'>" +
+    			"<conflict xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
+    			"</error>";
+        try {
+        	// Create the xml parser
+        	XmlPullParser parser = getParserFromXML(xml);
+        	// Create a packet from the xml
+        	XMPPError error = parseError(parser);
+        	
+            assertNotNull(error);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+    
+   public void testMessageAndApplicationDefinedError() {
+	   String xml = "<error type='modify' code='404'>" +
+	   		"<undefined-condition xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
+	   		"<text xml:lang='en' xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'>" +
+	   		"Some special application diagnostic information..." +
+	   		"</text>" +
+	   		"<special-application-condition xmlns='application-ns'/>" +
+	   		"</error>";
+       try {
+       	// Create the xml parser
+       	XmlPullParser parser = getParserFromXML(xml);
+       	// Create a packet from the xml
+       	XMPPError error = parseError(parser);
+       	
+       	String sendingXML = error.toXML();
+       	
+       assertNotNull(error);
+       assertNotNull(sendingXML);
+       } catch (Exception e) {
+           e.printStackTrace();
+           fail(e.getMessage());
+       }
+   }
+    /**
+     * Check the parser with an xml with the 404 error.
+    */
+    public void testCancelWithMessage() {
+        // Make the XML to test
+    	String xml = "<error type='cancel'>" +
+    			"<conflict xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
+    			"<text xmlns='urn:ietf:params:xml:ns:xmpp-stanzas' xml:lang='langcode'>" +
+    			"Some special application diagnostic information!" +
+    			"</text>" +
+    			"</error>";
+        try {
+        	// Create the xml parser
+        	XmlPullParser parser = getParserFromXML(xml);
+        	// Create a packet from the xml
+        	XMPPError error = parseError(parser);
+        	
+            assertNotNull(error);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+ 
+    /**
+     * Check the parser with an xml with the 404 error.
+    */
+    public void testCancelWithMessageAndApplicationError() {
+        // Make the XML to test
+    	String xml = "<error type='cancel' code='10'>" +
+    			"<conflict xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>" +
+    			"<text xml:lang='en' xmlns='urn:ietf:params:xml:ns:xmpp-streams'>" +
+    			"Some special application diagnostic information!" +
+    			"</text>" +
+    			"<application-defined-error xmlns='application-ns'/>" +
+    			"</error>";
+        try {
+        	// Create the xml parser
+        	XmlPullParser parser = getParserFromXML(xml);
+        	// Create a packet from the xml
+        	XMPPError error = parseError(parser);
+        	
+            assertNotNull(error);
+        } catch (Exception e) {
+            e.printStackTrace();
+            fail(e.getMessage());
+        }
+    }
+    
+    private XMPPError parseError(XmlPullParser parser) throws Exception {
+    	parser.next();
+    	return PacketParserUtils.parseError(parser);
+    }
+    
+    private XmlPullParser getParserFromXML(String xml) throws XmlPullParserException {
+    	XmlPullParser parser = XmlPullParserFactory.newInstance().newPullParser();
+    	parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, true);
+    	parser.setInput(new StringReader(xml));
+    	return parser;
+    }
+    
+    protected int getMaxConnections() {
+        return 0;
+    }
+}

smack-core/src/integration-test/resources/test-case.example.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0"?>
+<!-- Rename this file to test-case.xml to overwrite the default values of the Smack testcases -->
+<testcase>
+
+    <!-- Host and port of the XMPP server to use -->
+    <host>localhost</host>
+    <port>5222</port>
+
+    <!-- Username prefix to use for creating accounts. -->
+    <username>user</username>
+    <!-- Password prefix to use for creating connections -->
+    <!-- If same password is true, then the same password will be used for all accounts -->
+    <!-- If password is not set, the username will be used as password -->
+    <!--
+    <password same='true'>passw0rd</password>
+    -->
+    <!-- Chat and MUC domain names to use -->
+    <chat>chat</chat>
+    <muc>conference</muc>
+
+    <!-- LoginTest parameters -->
+    <testAnonymousLogin>false</testAnonymousLogin>
+
+    <!-- Account creation parameters -->
+    <!--
+    <accountCreationParameters email="test@xcp.localhost" name="test"/>
+    -->
+
+    <compressionEnabled>false</compressionEnabled>
+
+</testcase>