void tst_QXmppMessage::testMessageReceipt()
{
const QByteArray xml(
"<message id=\"richard2-4.1.247\" to=\"[email protected]/throne\" from=\"[email protected]/westminster\" type=\"normal\">"
"<body>My lord, dispatch; read o'er these articles.</body>"
"<request xmlns=\"urn:xmpp:receipts\"/>"
"</message>");
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.id(), QString("richard2-4.1.247"));
QCOMPARE(message.to(), QString("[email protected]/throne"));
QCOMPARE(message.from(), QString("[email protected]/westminster"));
QVERIFY(message.extendedAddresses().isEmpty());
QCOMPARE(message.type(), QXmppMessage::Normal);
QCOMPARE(message.body(), QString("My lord, dispatch; read o'er these articles."));
QCOMPARE(message.isAttentionRequested(), false);
QCOMPARE(message.isReceiptRequested(), true);
QCOMPARE(message.receiptId(), QString());
serializePacket(message, xml);
const QByteArray receiptXml(
"<message id=\"bi29sg183b4v\" to=\"[email protected]/westminster\" from=\"[email protected]/throne\" type=\"normal\">"
"<received xmlns=\"urn:xmpp:receipts\" id=\"richard2-4.1.247\"/>"
"</message>");
QXmppMessage receipt;
parsePacket(receipt, receiptXml);
QCOMPARE(receipt.id(), QString("bi29sg183b4v"));
QCOMPARE(receipt.to(), QString("[email protected]/westminster"));
QCOMPARE(receipt.from(), QString("[email protected]/throne"));
QVERIFY(receipt.extendedAddresses().isEmpty());
QCOMPARE(receipt.type(), QXmppMessage::Normal);
QCOMPARE(receipt.body(), QString());
QCOMPARE(receipt.isAttentionRequested(), false);
QCOMPARE(receipt.isReceiptRequested(), false);
QCOMPARE(receipt.receiptId(), QString("richard2-4.1.247"));
serializePacket(receipt, receiptXml);
const QByteArray oldXml(
"<message id=\"richard2-4.1.247\" to=\"[email protected]/westminster\" from=\"[email protected]/throne\" type=\"normal\">"
"<received xmlns=\"urn:xmpp:receipts\"/>"
"</message>");
QXmppMessage old;
parsePacket(old, oldXml);
QCOMPARE(old.id(), QString("richard2-4.1.247"));
QCOMPARE(old.to(), QString("[email protected]/westminster"));
QCOMPARE(old.from(), QString("[email protected]/throne"));
QVERIFY(old.extendedAddresses().isEmpty());
QCOMPARE(old.type(), QXmppMessage::Normal);
QCOMPARE(old.body(), QString());
QCOMPARE(old.isAttentionRequested(), false);
QCOMPARE(old.isReceiptRequested(), false);
QCOMPARE(old.receiptId(), QString("richard2-4.1.247"));
}
void tst_QXmppMessage::testBasic()
{
QFETCH(QByteArray, xml);
QFETCH(int, type);
QFETCH(QString, body);
QFETCH(QString, subject);
QFETCH(QString, thread);
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.to(), QString("[email protected]/QXmpp"));
QCOMPARE(message.from(), QString("[email protected]/QXmpp"));
QVERIFY(message.extendedAddresses().isEmpty());
QCOMPARE(int(message.type()), type);
QCOMPARE(message.body(), body);
QCOMPARE(message.subject(), subject);
QCOMPARE(message.thread(), thread);
QCOMPARE(message.state(), QXmppMessage::None);
QCOMPARE(message.isAttentionRequested(), false);
QCOMPARE(message.isReceiptRequested(), false);
QCOMPARE(message.hasForwarded(), false);
QCOMPARE(message.receiptId(), QString());
QCOMPARE(message.xhtml(), QString());
serializePacket(message, xml);
}
void tst_QXmppMessage::testReplaceWithEmptyMessage()
{
const QByteArray replaceXml(
"<message to='[email protected]/balcony' id='good1'>"
"<body/>"
"<replace id='bad1' xmlns='urn:xmpp:message-correct:0'/>"
"</message>");
QXmppMessage replaceMessage;
parsePacket(replaceMessage, replaceXml);
QCOMPARE(replaceMessage.isReplace(), true);
QCOMPARE(replaceMessage.replaceId(), QString("bad1"));
QCOMPARE(replaceMessage.body(), QString(""));
const QByteArray replaceSerialisation(
"<message id=\"good1\" to=\"[email protected]/balcony\" type=\"chat\">"
"<body/>"
"<replace id=\"bad1\" xmlns=\"urn:xmpp:message-correct:0\"/>"
"</message>");
QXmppMessage serialisationMessage;
serialisationMessage.setTo("[email protected]/balcony");
serialisationMessage.setId("good1");
serialisationMessage.setBody("");
serialisationMessage.setReplace("bad1");
serializePacket(serialisationMessage, replaceSerialisation);
}
void tst_QXmppMessage::testProcessingHints()
{
const QByteArray xml("<message "
"to=\"[email protected]/laptop\" "
"from=\"[email protected]/laptop\" "
"type=\"chat\">"
"<body>V unir avtug'f pybnx gb uvqr zr sebz gurve fvtug</body>"
"<no-copy xmlns=\"urn:xmpp:hints\"/>"
"<no-store xmlns=\"urn:xmpp:hints\"/>"
"<allow-permanent-storage xmlns=\"urn:xmpp:hints\"/>"
"</message>");
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.hasHint(QXmppMessage::NoCopies), true);
QCOMPARE(message.hasHint(QXmppMessage::NoStorage), true);
QCOMPARE(message.hasHint(QXmppMessage::AllowPermantStorage), true);
QXmppMessage message2;
message2.setType(QXmppMessage::Chat);
message2.setFrom(QString("[email protected]/laptop"));
message2.setTo(QString("[email protected]/laptop"));
message2.setBody(QString("V unir avtug'f pybnx gb uvqr zr sebz gurve fvtug"));
message2.addHint(QXmppMessage::NoCopies);
message2.addHint(QXmppMessage::NoStorage);
message2.addHint(QXmppMessage::AllowPermantStorage);
serializePacket(message2, xml);
}
void* sendPackets(void* data) {
// Send Header
Header* h = initHeader(filename, "dave");
char* h_s = serializeHeader(h);
sendto(sock, h_s, strlen(h_s), 0, (struct sockaddr *) &servAddr, sizeof(servAddr));
// Send the packets
for (;;) {
if (!isEmpty(ph)) {
char *s;
Packet* p = malloc(sizeof(Packet));
getLock(ph);
p = removePacket(ph, p); // Get packet
unlock(ph);
s = serializePacket(p); // Convert into sendable char array
sendto(sock, s, strlen(s), 0, (struct sockaddr *) &servAddr, sizeof(servAddr));
if (p->fragment == DUMMY_FRAG_NUM) {
printf("Done Sending!!\n");
pthread_exit(0);
}
}
}
}
void tst_QXmppJingleIq::testCandidate()
{
const QByteArray xml(
"<candidate component=\"1\""
" foundation=\"1\""
" generation=\"0\""
" id=\"el0747fg11\""
" ip=\"10.0.1.1\""
" network=\"1\""
" port=\"8998\""
" priority=\"2130706431\""
" protocol=\"udp\""
" type=\"host\"/>");
QXmppJingleCandidate candidate;
parsePacket(candidate, xml);
QCOMPARE(candidate.foundation(), QLatin1String("1"));
QCOMPARE(candidate.generation(), 0);
QCOMPARE(candidate.id(), QLatin1String("el0747fg11"));
QCOMPARE(candidate.host(), QHostAddress("10.0.1.1"));
QCOMPARE(candidate.network(), 1);
QCOMPARE(candidate.port(), quint16(8998));
QCOMPARE(candidate.priority(), 2130706431);
QCOMPARE(candidate.protocol(), QLatin1String("udp"));
QCOMPARE(candidate.type(), QXmppJingleCandidate::HostType);
serializePacket(candidate, xml);
};
void tst_QXmppRegisterIq::testResult()
{
const QByteArray xml(
"<iq id=\"reg1\" type=\"result\">"
"<query xmlns=\"jabber:iq:register\">"
"<instructions>Choose a username and password for use with this service. Please also provide your email address.</instructions>"
"<username/>"
"<password/>"
"<email/>"
"</query>"
"</iq>");
QXmppRegisterIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.id(), QLatin1String("reg1"));
QCOMPARE(iq.to(), QString());
QCOMPARE(iq.from(), QString());
QCOMPARE(iq.type(), QXmppIq::Result);
QCOMPARE(iq.instructions(), QLatin1String("Choose a username and password for use with this service. Please also provide your email address."));
QVERIFY(!iq.username().isNull());
QVERIFY(iq.username().isEmpty());
QVERIFY(!iq.password().isNull());
QVERIFY(iq.password().isEmpty());
QVERIFY(!iq.email().isNull());
QVERIFY(iq.email().isEmpty());
QVERIFY(iq.form().isNull());
serializePacket(iq, xml);
}
void tst_QXmppVCardIq::testAddress()
{
QFETCH(QByteArray, xml);
QFETCH(int, type);
QFETCH(QString, country);
QFETCH(QString, locality);
QFETCH(QString, postcode);
QFETCH(QString, region);
QFETCH(QString, street);
QFETCH(bool, equalsEmpty);
QXmppVCardAddress address;
parsePacket(address, xml);
QCOMPARE(int(address.type()), type);
QCOMPARE(address.country(), country);
QCOMPARE(address.locality(), locality);
QCOMPARE(address.postcode(), postcode);
QCOMPARE(address.region(), region);
QCOMPARE(address.street(), street);
serializePacket(address, xml);
QXmppVCardAddress addressCopy = address;
QVERIFY2(addressCopy == address, "QXmppVCardAddres::operator==() fails");
QVERIFY2(!(addressCopy != address), "QXmppVCardAddres::operator!=() fails");
QXmppVCardAddress emptyAddress;
QCOMPARE(emptyAddress == address, equalsEmpty);
QCOMPARE(emptyAddress != address, !equalsEmpty);
}
void TestPubSub::testSubscription()
{
const QByteArray xml(
"<iq"
" id=\"sub1\""
" to=\"[email protected]/barracks\""
" from=\"pubsub.shakespeare.lit\""
" type=\"result\">"
"<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
"<subscription jid=\"[email protected]\""
" node=\"princely_musings\""
" subid=\"ba49252aaa4f5d320c24d3766f0bdcade78c78d3\""
" subscription=\"subscribed\"/>"
"</pubsub>"
"</iq>");
QXmppPubSubIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.id(), QLatin1String("sub1"));
QCOMPARE(iq.to(), QLatin1String("[email protected]/barracks"));
QCOMPARE(iq.from(), QLatin1String("pubsub.shakespeare.lit"));
QCOMPARE(iq.type(), QXmppIq::Result);
QCOMPARE(iq.queryType(), QXmppPubSubIq::SubscriptionQuery);
QCOMPARE(iq.queryJid(), QLatin1String("*****@*****.**"));
QCOMPARE(iq.queryNode(), QLatin1String("princely_musings"));
QCOMPARE(iq.subscriptionId(), QLatin1String("ba49252aaa4f5d320c24d3766f0bdcade78c78d3"));
serializePacket(iq, xml);
}
void TestPubSub::testPublish()
{
const QByteArray xml(
"<iq"
" id=\"items1\""
" to=\"pubsub.shakespeare.lit\""
" from=\"[email protected]/barracks\""
" type=\"result\">"
"<pubsub xmlns=\"http://jabber.org/protocol/pubsub\">"
"<publish node=\"storage:bookmarks\">"
"<item id=\"current\">"
"<storage xmlns=\"storage:bookmarks\">"
"<conference"
" autojoin=\"true\""
" jid=\"[email protected]\""
" name=\"The Play's the Thing\">"
"<nick>JC</nick>"
"</conference>"
"</storage>"
"</item>"
"</publish>"
"</pubsub>"
"</iq>");
QXmppPubSubIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.id(), QLatin1String("items1"));
QCOMPARE(iq.to(), QLatin1String("pubsub.shakespeare.lit"));
QCOMPARE(iq.from(), QLatin1String("[email protected]/barracks"));
QCOMPARE(iq.type(), QXmppIq::Result);
QCOMPARE(iq.queryType(), QXmppPubSubIq::PublishQuery);
QCOMPARE(iq.queryJid(), QString());
QCOMPARE(iq.queryNode(), QLatin1String("storage:bookmarks"));
serializePacket(iq, xml);
}
void TestPackets::testPresenceWithCapability()
{
const QByteArray xml(
"<presence to=\"[email protected]/QXmpp\" from=\"[email protected]/QXmpp\">"
"<show>away</show>"
"<status>In a meeting</status>"
"<priority>5</priority>"
"<x xmlns=\"vcard-temp:x:update\">"
"<photo>73b908bc</photo>"
"</x>"
"<c xmlns=\"http://jabber.org/protocol/caps\" hash=\"sha-1\" node=\"http://code.google.com/p/qxmpp\" ver=\"QgayPKawpkPSDYmwT/WM94uAlu0=\"/>"
"</presence>");
QXmppPresence presence;
parsePacket(presence, xml);
QCOMPARE(presence.to(), QString("[email protected]/QXmpp"));
QCOMPARE(presence.from(), QString("[email protected]/QXmpp"));
QCOMPARE(presence.status().type(), QXmppPresence::Status::Away);
QCOMPARE(presence.status().statusText(), QString("In a meeting"));
QCOMPARE(presence.status().priority(), 5);
QCOMPARE(presence.photoHash(), QByteArray::fromHex("73b908bc"));
QCOMPARE(presence.vCardUpdateType(), QXmppPresence::VCardUpdateValidPhoto);
QCOMPARE(presence.capabilityHash(), QString("sha-1"));
QCOMPARE(presence.capabilityNode(), QString("http://code.google.com/p/qxmpp"));
QCOMPARE(presence.capabilityVer(), QByteArray::fromBase64("QgayPKawpkPSDYmwT/WM94uAlu0="));
serializePacket(presence, xml);
}
void TestPackets::testArchiveChat()
{
const QByteArray xml(
"<iq id=\"chat_1\" type=\"result\">"
"<chat xmlns=\"urn:xmpp:archive\""
" with=\"[email protected]\""
" start=\"1469-07-21T02:56:15Z\""
" subject=\"She speaks!\""
" version=\"4\""
">"
"<from secs=\"0\"><body>Art thou not Romeo, and a Montague?</body></from>"
"<to secs=\"11\"><body>Neither, fair saint, if either thee dislike.</body></to>"
"</chat>"
"</iq>");
QXmppArchiveChatIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.type(), QXmppIq::Result);
QCOMPARE(iq.id(), QLatin1String("chat_1"));
QCOMPARE(iq.chat().with(), QLatin1String("*****@*****.**"));
QCOMPARE(iq.chat().messages().size(), 2);
QCOMPARE(iq.chat().messages()[0].isReceived(), true);
QCOMPARE(iq.chat().messages()[0].body(), QLatin1String("Art thou not Romeo, and a Montague?"));
QCOMPARE(iq.chat().messages()[0].date(), QDateTime(QDate(1469, 7, 21), QTime(2, 56, 15), Qt::UTC));
QCOMPARE(iq.chat().messages()[1].isReceived(), false);
QCOMPARE(iq.chat().messages()[1].date(), QDateTime(QDate(1469, 7, 21), QTime(2, 56, 26), Qt::UTC));
QCOMPARE(iq.chat().messages()[1].body(), QLatin1String("Neither, fair saint, if either thee dislike."));
serializePacket(iq, xml);
}
void TestDiagnostics::testPacket()
{
const QByteArray xml(
"<iq type=\"result\">"
"<query xmlns=\"http://wifirst.net/protocol/diagnostics\">"
"<software type=\"os\" name=\"Windows\" version=\"XP\"/>"
"<interface name=\"en1\">"
"<address broadcast=\"\" ip=\"FE80:0:0:0:226:8FF:FEE1:A96B\" netmask=\"FFFF:FFFF:FFFF:FFFF:0:0:0:0\"/>"
"<address broadcast=\"192.168.99.255\" ip=\"192.168.99.179\" netmask=\"255.255.255.0\"/>"
"<wireless standards=\"ABGN\">"
"<network current=\"1\" cinr=\"-91\" rssi=\"-59\" ssid=\"Maki\"/>"
"<network cinr=\"-92\" rssi=\"-45\" ssid=\"freephonie\"/>"
"</wireless>"
"</interface>"
"<lookup hostName=\"www.google.fr\">"
"<address>2A00:1450:4007:800:0:0:0:68</address>"
"<address>66.249.92.104</address>"
"</lookup>"
"<ping hostAddress=\"192.168.99.1\" minimumTime=\"1.657\" maximumTime=\"44.275\" averageTime=\"20.258\" sentPackets=\"3\" receivedPackets=\"3\"/>"
"<traceroute hostAddress=\"213.91.4.201\">"
"<ping hostAddress=\"192.168.99.1\" minimumTime=\"1.719\" maximumTime=\"4.778\" averageTime=\"3.596\" sentPackets=\"3\" receivedPackets=\"3\"/>"
"</traceroute>"
"</query>"
"</iq>");
DiagnosticsIq iq;
parsePacket(iq, xml);
serializePacket(iq, xml);
}
void TestXmlRpc::testResponse()
{
const QByteArray xml(
"<iq"
" id=\"rpc1\""
" to=\"[email protected]/jrpc-client\""
" from=\"[email protected]/jrpc-server\""
" type=\"result\">"
"<query xmlns=\"jabber:iq:rpc\">"
"<methodResponse>"
"<params>"
"<param>"
"<value><string>Colorado</string></value>"
"</param>"
"</params>"
"</methodResponse>"
"</query>"
"</iq>");
QXmppRpcResponseIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.faultCode(), 0);
QCOMPARE(iq.faultString(), QString());
QCOMPARE(iq.values(), QVariantList() << QString("Colorado"));
serializePacket(iq, xml);
}
void TestXmlRpc::testResponseFault()
{
const QByteArray xml(
"<iq"
" id=\"rpc1\""
" to=\"[email protected]/jrpc-client\""
" from=\"[email protected]/jrpc-server\""
" type=\"result\">"
"<query xmlns=\"jabber:iq:rpc\">"
"<methodResponse>"
"<fault>"
"<value>"
"<struct>"
"<member>"
"<name>faultCode</name>"
"<value><i4>404</i4></value>"
"</member>"
"<member>"
"<name>faultString</name>"
"<value><string>Not found</string></value>"
"</member>"
"</struct>"
"</value>"
"</fault>"
"</methodResponse>"
"</query>"
"</iq>");
QXmppRpcResponseIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.faultCode(), 404);
QCOMPARE(iq.faultString(), QLatin1String("Not found"));
QCOMPARE(iq.values(), QVariantList());
serializePacket(iq, xml);
}
void TestJingle::testSession()
{
const QByteArray xml(
"<iq"
" id=\"zid615d9\""
" to=\"[email protected]/balcony\""
" from=\"[email protected]/orchard\""
" type=\"set\">"
"<jingle xmlns=\"urn:xmpp:jingle:1\""
" action=\"session-initiate\""
" initiator=\"[email protected]/orchard\""
" sid=\"a73sjjvkla37jfea\">"
"<content creator=\"initiator\" name=\"this-is-a-stub\">"
"<description xmlns=\"urn:xmpp:jingle:apps:stub:0\"/>"
"<transport xmlns=\"urn:xmpp:jingle:transports:stub:0\"/>"
"</content>"
"</jingle>"
"</iq>");
QXmppJingleIq session;
parsePacket(session, xml);
QCOMPARE(session.action(), QXmppJingleIq::SessionInitiate);
QCOMPARE(session.initiator(), QLatin1String("[email protected]/orchard"));
QCOMPARE(session.sid(), QLatin1String("a73sjjvkla37jfea"));
QCOMPARE(session.content().creator(), QLatin1String("initiator"));
QCOMPARE(session.content().name(), QLatin1String("this-is-a-stub"));
QCOMPARE(session.reason().text(), QString());
QCOMPARE(session.reason().type(), QXmppJingleIq::Reason::None);
serializePacket(session, xml);
}
void TestXmlRpc::testInvoke()
{
const QByteArray xml(
"<iq"
" id=\"rpc1\""
" to=\"[email protected]/jrpc-server\""
" from=\"[email protected]/jrpc-client\""
" type=\"set\">"
"<query xmlns=\"jabber:iq:rpc\">"
"<methodCall>"
"<methodName>examples.getStateName</methodName>"
"<params>"
"<param>"
"<value><i4>6</i4></value>"
"</param>"
"</params>"
"</methodCall>"
"</query>"
"</iq>");
QXmppRpcInvokeIq iq;
parsePacket(iq, xml);
QCOMPARE(iq.method(), QLatin1String("examples.getStateName"));
QCOMPARE(iq.arguments(), QVariantList() << int(6));
serializePacket(iq, xml);
}
void tst_QXmppSasl::testSuccess()
{
const QByteArray xml = "<success xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>";
QXmppSaslSuccess stanza;
parsePacket(stanza, xml);
serializePacket(stanza, xml);
}
void TestJingle::testTerminate()
{
const QByteArray xml(
"<iq"
" id=\"le71fa63\""
" to=\"[email protected]/orchard\""
" from=\"[email protected]/balcony\""
" type=\"set\">"
"<jingle xmlns=\"urn:xmpp:jingle:1\""
" action=\"session-terminate\""
" sid=\"a73sjjvkla37jfea\">"
"<reason>"
"<success/>"
"</reason>"
"</jingle>"
"</iq>");
QXmppJingleIq session;
parsePacket(session, xml);
QCOMPARE(session.action(), QXmppJingleIq::SessionTerminate);
QCOMPARE(session.initiator(), QString());
QCOMPARE(session.sid(), QLatin1String("a73sjjvkla37jfea"));
QCOMPARE(session.reason().text(), QString());
QCOMPARE(session.reason().type(), QXmppJingleIq::Reason::Success);
serializePacket(session, xml);
}
void tst_QXmppSasl::testFailure()
{
// no condition
const QByteArray xml = "<failure xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"/>";
QXmppSaslFailure failure;
parsePacket(failure, xml);
QCOMPARE(failure.condition(), QString());
serializePacket(failure, xml);
// not authorized
const QByteArray xml2 = "<failure xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\"><not-authorized/></failure>";
QXmppSaslFailure failure2;
parsePacket(failure2, xml2);
QCOMPARE(failure2.condition(), QLatin1String("not-authorized"));
serializePacket(failure2, xml2);
}
void TestPackets::testNonSaslAuth()
{
// Client Requests Authentication Fields from Server
const QByteArray xml1(
"<iq id=\"auth1\" to=\"shakespeare.lit\" type=\"get\">"
"<query xmlns=\"jabber:iq:auth\"/>"
"</iq>");
QXmppNonSASLAuthIq iq1;
parsePacket(iq1, xml1);
serializePacket(iq1, xml1);
// Client Provides Required Information (Plaintext)
const QByteArray xml3(
"<iq id=\"auth2\" type=\"set\">"
"<query xmlns=\"jabber:iq:auth\">"
"<username>bill</username>"
"<password>Calli0pe</password>"
"<resource>globe</resource>"
"</query>"
"</iq>");
QXmppNonSASLAuthIq iq3;
parsePacket(iq3, xml3);
QCOMPARE(iq3.username(), QLatin1String("bill"));
QCOMPARE(iq3.digest(), QByteArray());
QCOMPARE(iq3.password(), QLatin1String("Calli0pe"));
QCOMPARE(iq3.resource(), QLatin1String("globe"));
serializePacket(iq3, xml3);
// Client Provides Required Information (Plaintext)
const QByteArray xml4(
"<iq id=\"auth2\" type=\"set\">"
"<query xmlns=\"jabber:iq:auth\">"
"<username>bill</username>"
"<digest>48fc78be9ec8f86d8ce1c39c320c97c21d62334d</digest>"
"<resource>globe</resource>"
"</query>"
"</iq>");
QXmppNonSASLAuthIq iq4;
parsePacket(iq4, xml4);
QCOMPARE(iq4.username(), QLatin1String("bill"));
QCOMPARE(iq4.digest(), QByteArray("\x48\xfc\x78\xbe\x9e\xc8\xf8\x6d\x8c\xe1\xc3\x9c\x32\x0c\x97\xc2\x1d\x62\x33\x4d"));
QCOMPARE(iq4.password(), QString());
QCOMPARE(iq4.resource(), QLatin1String("globe"));
serializePacket(iq4, xml4);
}
void tst_QXmppMessage::testState()
{
QFETCH(QByteArray, xml);
QFETCH(int, state);
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(int(message.state()), state);
serializePacket(message, xml);
}
void tst_QXmppMessage::testDelay()
{
QFETCH(QByteArray, xml);
QFETCH(QDateTime, stamp);
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.stamp(), stamp);
serializePacket(message, xml);
}
void tst_QXmppVCardIq::testPhone()
{
QFETCH(QByteArray, xml);
QFETCH(int, type);
QXmppVCardPhone phone;
parsePacket(phone, xml);
QCOMPARE(phone.number(), QLatin1String("12345"));
QCOMPARE(int(phone.type()), type);
serializePacket(phone, xml);
}
void
DebugNet::writePacket(DebugPacket *pak)
{
gLog->debug("Writing packet {}", (int)pak->type());
std::vector<uint8_t> buffer;
serializePacket(buffer, pak);
SOCKET sock = (SOCKET)mSocket;
send(sock, (char*)&buffer[0], (int)buffer.size(), 0);
}
void tst_QXmppSasl::testChallenge()
{
QFETCH(QByteArray, xml);
QFETCH(QByteArray, value);
// no condition
QXmppSaslChallenge challenge;
parsePacket(challenge, xml);
QCOMPARE(challenge.value(), value);
serializePacket(challenge, xml);
}
void TestJingle::testPayloadType()
{
const QByteArray xml("<payload-type id=\"103\" name=\"L16\" channels=\"2\" clockrate=\"16000\"/>");
QXmppJinglePayloadType payload;
parsePacket(payload, xml);
QCOMPARE(payload.id(), static_cast<unsigned char>(103));
QCOMPARE(payload.name(), QLatin1String("L16"));
QCOMPARE(payload.channels(), static_cast<unsigned char>(2));
QCOMPARE(payload.clockrate(), 16000u);
serializePacket(payload, xml);
}
void tst_QXmppSasl::testResponse()
{
QFETCH(QByteArray, xml);
QFETCH(QByteArray, value);
// no condition
QXmppSaslResponse response;
parsePacket(response, xml);
QCOMPARE(response.value(), value);
serializePacket(response, xml);
}
void tst_QXmppVCardIq::testEmail()
{
QFETCH(QByteArray, xml);
QFETCH(int, type);
QXmppVCardEmail email;
parsePacket(email, xml);
QCOMPARE(email.address(), QLatin1String("*****@*****.**"));
QCOMPARE(int(email.type()), type);
serializePacket(email, xml);
}
void TestPackets::testMessage()
{
const QByteArray xml(
"<message to=\"[email protected]/QXmpp\" from=\"[email protected]/QXmpp\" type=\"normal\"/>");
QXmppMessage message;
parsePacket(message, xml);
QCOMPARE(message.to(), QString("[email protected]/QXmpp"));
QCOMPARE(message.from(), QString("[email protected]/QXmpp"));
serializePacket(message, xml);
}
