174 lines
6.3 KiB
Plaintext
174 lines
6.3 KiB
Plaintext
/**
|
|
*
|
|
* Copyright the original author or authors
|
|
*
|
|
* 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.
|
|
*/
|
|
// TODO this should become PingManagerTest
|
|
|
|
//package org.jivesoftware.smackx.ping;
|
|
//
|
|
//import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
|
|
//import static org.junit.Assert.assertTrue;
|
|
//
|
|
//import java.util.Properties;
|
|
//import java.util.concurrent.CountDownLatch;
|
|
//import java.util.concurrent.TimeUnit;
|
|
//
|
|
//import org.jivesoftware.smack.XMPPConnection;
|
|
//import org.jivesoftware.smack.DummyConnection;
|
|
//import org.jivesoftware.smack.PacketInterceptor;
|
|
//import org.jivesoftware.smack.PacketListener;
|
|
//import org.jivesoftware.smack.SmackConfiguration;
|
|
//import org.jivesoftware.smack.ThreadedDummyConnection;
|
|
//import org.jivesoftware.smack.filter.IQTypeFilter;
|
|
//import org.jivesoftware.smack.filter.PacketTypeFilter;
|
|
//import org.jivesoftware.smack.packet.IQ;
|
|
//import org.jivesoftware.smack.packet.Packet;
|
|
//import org.jivesoftware.smack.pingx.packet.Ping;
|
|
//import org.jivesoftware.smackx.ping.PingFailedListener;
|
|
//import org.junit.After;
|
|
//import org.junit.Before;
|
|
//import org.junit.Test;
|
|
//
|
|
//public class KeepaliveTest {
|
|
// private static final long PING_MINIMUM = 1000;
|
|
// private static String TO = "juliet@capulet.lit/balcony";
|
|
// private static String ID = "s2c1";
|
|
//
|
|
// private static Properties outputProperties = new Properties();
|
|
// {
|
|
// outputProperties.put(javax.xml.transform.OutputKeys.OMIT_XML_DECLARATION, "yes");
|
|
// }
|
|
//
|
|
// private int originalTimeout;
|
|
//
|
|
// @Before
|
|
// public void resetProperties()
|
|
// {
|
|
// SmackConfiguration.setKeepAliveInterval(-1);
|
|
// originalTimeout = SmackConfiguration.getPacketReplyTimeout();
|
|
// SmackConfiguration.setPacketReplyTimeout(1000);
|
|
// }
|
|
//
|
|
// @After
|
|
// public void restoreProperties()
|
|
// {
|
|
// SmackConfiguration.setPacketReplyTimeout(originalTimeout);
|
|
// }
|
|
// /*
|
|
// * Stanza copied from spec
|
|
// */
|
|
// @Test
|
|
// public void validatePingStanzaXML() throws Exception {
|
|
// // @formatter:off
|
|
// String control = "<iq to='juliet@capulet.lit/balcony' id='s2c1' type='get'>"
|
|
// + "<ping xmlns='urn:xmpp:ping'/></iq>";
|
|
// // @formatter:on
|
|
//
|
|
// Ping ping = new Ping(TO);
|
|
// ping.setPacketID(ID);
|
|
//
|
|
// assertXMLEqual(control, ping.toXML());
|
|
// }
|
|
//
|
|
// @Test
|
|
// public void serverPingFailSingleConnection() throws Exception {
|
|
// DummyConnection connection = getConnection();
|
|
// CountDownLatch latch = new CountDownLatch(2);
|
|
// addInterceptor(connection, latch);
|
|
// addPingFailedListener(connection, latch);
|
|
//
|
|
// // Time based testing kind of sucks, but this should be reliable on a DummyConnection since there
|
|
// // is no actual server involved. This will provide enough time to ping and wait for the lack of response.
|
|
// assertTrue(latch.await(getWaitTime(), TimeUnit.MILLISECONDS));
|
|
// }
|
|
//
|
|
// @Test
|
|
// public void serverPingSuccessfulSingleConnection() throws Exception {
|
|
// ThreadedDummyConnection connection = getThreadedConnection();
|
|
// final CountDownLatch latch = new CountDownLatch(1);
|
|
//
|
|
// connection.addPacketListener(new PacketListener() {
|
|
// @Override
|
|
// public void processPacket(Packet packet) {
|
|
// latch.countDown();
|
|
// }
|
|
// }, new IQTypeFilter(IQ.Type.result));
|
|
//
|
|
// // Time based testing kind of sucks, but this should be reliable on a DummyConnection since there
|
|
// // is no actual server involved. This will provide enough time to ping and wait for the lack of response.
|
|
// assertTrue(latch.await(getWaitTime(), TimeUnit.MILLISECONDS));
|
|
// }
|
|
//
|
|
// @Test
|
|
// public void serverPingFailMultipleConnection() throws Exception {
|
|
// CountDownLatch latch = new CountDownLatch(6);
|
|
// SmackConfiguration.setPacketReplyTimeout(15000);
|
|
//
|
|
// DummyConnection con1 = getConnection();
|
|
// addInterceptor(con1, latch);
|
|
// addPingFailedListener(con1, latch);
|
|
//
|
|
// DummyConnection con2 = getConnection();
|
|
// addInterceptor(con2, latch);
|
|
// addPingFailedListener(con2, latch);
|
|
//
|
|
// DummyConnection con3 = getConnection();
|
|
// addInterceptor(con3, latch);
|
|
// addPingFailedListener(con2, latch);
|
|
//
|
|
// assertTrue(latch.await(getWaitTime(), TimeUnit.MILLISECONDS));
|
|
// }
|
|
//
|
|
// private void addPingFailedListener(DummyConnection con, final CountDownLatch latch) {
|
|
// KeepAliveManager manager = KeepAliveManager.getInstanceFor(con);
|
|
// manager.addPingFailedListener(new PingFailedListener() {
|
|
// @Override
|
|
// public void pingFailed() {
|
|
// latch.countDown();
|
|
// }
|
|
// });
|
|
// }
|
|
//
|
|
// private DummyConnection getConnection() {
|
|
// DummyConnection con = new DummyConnection();
|
|
// KeepAliveManager mgr = KeepAliveManager.getInstanceFor(con);
|
|
// mgr.setPingInterval(PING_MINIMUM);
|
|
//
|
|
// return con;
|
|
// }
|
|
//
|
|
// private ThreadedDummyConnection getThreadedConnection() {
|
|
// ThreadedDummyConnection con = new ThreadedDummyConnection();
|
|
// KeepAliveManager mgr = KeepAliveManager.getInstanceFor(con);
|
|
// mgr.setPingInterval(PING_MINIMUM);
|
|
//
|
|
// return con;
|
|
// }
|
|
//
|
|
// private void addInterceptor(final XMPPConnection con, final CountDownLatch latch) {
|
|
// con.addPacketInterceptor(new PacketInterceptor() {
|
|
// @Override
|
|
// public void interceptPacket(Packet packet) {
|
|
// con.removePacketInterceptor(this);
|
|
// latch.countDown();
|
|
// }
|
|
// }, new PacketTypeFilter(Ping.class));
|
|
// }
|
|
//
|
|
// private long getWaitTime() {
|
|
// return PING_MINIMUM + SmackConfiguration.getPacketReplyTimeout() + 3000;
|
|
// }
|
|
//}
|