mirror of
https://codeberg.org/Mercury-IM/Smack
synced 2025-12-06 05:01:12 +01:00
Replace XPP3 by XmlPullParser interface wrapping StAX and XPP3
Introducing Smack's own XmlPullParser interface which tries to stay as compatible as possible to XPP3. The interface is used to either wrap StAX's XMLStreamReader if Smack is used on Java SE, and XPP3's XmlPullParser if Smack is used on on Android. Fixes SMACK-591. Also introduce JUnit 5 and non-strict javadoc projects.
This commit is contained in:
Florian Schmaus
parent
b3646abecd
commit
4133eb175c
414 changed files with 3855 additions and 2041 deletions
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2018 Florian Schmaus
|
||||
* Copyright 2018-2019 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -22,9 +22,9 @@ import org.jivesoftware.smack.compress.packet.Failure;
|
|||
import org.jivesoftware.smack.packet.StanzaError;
|
||||
import org.jivesoftware.smack.packet.StanzaError.Condition;
|
||||
import org.jivesoftware.smack.util.PacketParserUtils;
|
||||
import org.jivesoftware.smack.xml.XmlPullParser;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
|
||||
public class FailureProviderTest {
|
||||
|
||||
|
|
|
|||
|
|
@ -18,19 +18,25 @@ package org.jivesoftware.smack.packet;
|
|||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import org.jivesoftware.smack.packet.StreamError.Condition;
|
||||
import org.jivesoftware.smack.parsing.SmackParsingException;
|
||||
import org.jivesoftware.smack.test.util.SmackTestUtil;
|
||||
import org.jivesoftware.smack.util.PacketParserUtils;
|
||||
import org.jivesoftware.smack.xml.XmlPullParser;
|
||||
import org.jivesoftware.smack.xml.XmlPullParserException;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.EnumSource;
|
||||
|
||||
public class StreamErrorTest {
|
||||
|
||||
@Test
|
||||
public void testParsingOfSimpleStreamError() {
|
||||
StreamError error = null;
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testParsingOfSimpleStreamError(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
final String xml =
|
||||
// Usually the stream:stream element has more attributes (to, version, ...)
|
||||
// We omit those, since they are not relevant for testing
|
||||
|
|
@ -39,19 +45,17 @@ public class StreamErrorTest {
|
|||
"<conflict xmlns='urn:ietf:params:xml:ns:xmpp-streams' /> +" +
|
||||
"</stream:error>" +
|
||||
"</stream:stream>";
|
||||
try {
|
||||
XmlPullParser parser = PacketParserUtils.getParserFor(xml, "error");
|
||||
error = PacketParserUtils.parseStreamError(parser);
|
||||
} catch (Exception e) {
|
||||
fail(e.getMessage());
|
||||
}
|
||||
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(xml, "error", parserKind);
|
||||
StreamError error = PacketParserUtils.parseStreamError(parser);
|
||||
|
||||
assertNotNull(error);
|
||||
assertEquals(Condition.conflict, error.getCondition());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParsingOfStreamErrorWithText() {
|
||||
StreamError error = null;
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testParsingOfStreamErrorWithText(SmackTestUtil.XmlPullParserKind parserKind) throws XmlPullParserException, IOException, SmackParsingException {
|
||||
final String xml =
|
||||
// Usually the stream:stream element has more attributes (to, version, ...)
|
||||
// We omit those, since they are not relevant for testing
|
||||
|
|
@ -63,20 +67,19 @@ public class StreamErrorTest {
|
|||
"</text>" +
|
||||
"</stream:error>" +
|
||||
"</stream:stream>";
|
||||
try {
|
||||
XmlPullParser parser = PacketParserUtils.getParserFor(xml, "error");
|
||||
error = PacketParserUtils.parseStreamError(parser);
|
||||
} catch (Exception e) {
|
||||
fail(e.getMessage());
|
||||
}
|
||||
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(xml, "error", parserKind);
|
||||
StreamError error = PacketParserUtils.parseStreamError(parser);
|
||||
|
||||
assertNotNull(error);
|
||||
assertEquals(Condition.conflict, error.getCondition());
|
||||
assertEquals("Replaced by new connection", error.getDescriptiveText());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParsingOfStreamErrorWithTextAndOptionalElement() {
|
||||
StreamError error = null;
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testParsingOfStreamErrorWithTextAndOptionalElement(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
final String xml =
|
||||
// Usually the stream:stream element has more attributes (to, version, ...)
|
||||
// We omit those, since they are not relevant for testing
|
||||
|
|
@ -91,12 +94,10 @@ public class StreamErrorTest {
|
|||
"</appSpecificElement>" +
|
||||
"</stream:error>" +
|
||||
"</stream:stream>";
|
||||
try {
|
||||
XmlPullParser parser = PacketParserUtils.getParserFor(xml, "error");
|
||||
error = PacketParserUtils.parseStreamError(parser);
|
||||
} catch (Exception e) {
|
||||
fail(e.getMessage());
|
||||
}
|
||||
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(xml, "error", parserKind);
|
||||
StreamError error = PacketParserUtils.parseStreamError(parser);
|
||||
|
||||
assertNotNull(error);
|
||||
assertEquals(Condition.conflict, error.getCondition());
|
||||
assertEquals("Replaced by new connection", error.getDescriptiveText());
|
||||
|
|
@ -104,21 +105,20 @@ public class StreamErrorTest {
|
|||
assertNotNull(appSpecificElement);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStreamErrorXmlNotWellFormed() {
|
||||
StreamError error = null;
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testStreamErrorXmlNotWellFormed(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
final String xml =
|
||||
// Usually the stream:stream element has more attributes (to, version, ...)
|
||||
// We omit those, since they are not relevant for testing
|
||||
"<stream:stream from='im.example.com' id='++TR84Sm6A3hnt3Q065SnAbbk3Y=' xmlns:stream='http://etherx.jabber.org/streams'>" +
|
||||
"<stream:error><xml-not-well-formed xmlns='urn:ietf:params:xml:ns:xmpp-streams'/></stream:error>" +
|
||||
"</stream:stream>";
|
||||
try {
|
||||
XmlPullParser parser = PacketParserUtils.getParserFor(xml, "error");
|
||||
error = PacketParserUtils.parseStreamError(parser);
|
||||
} catch (Exception e) {
|
||||
fail(e.getMessage());
|
||||
}
|
||||
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(xml, "error", parserKind);
|
||||
StreamError error = PacketParserUtils.parseStreamError(parser);
|
||||
|
||||
assertNotNull(error);
|
||||
assertEquals(Condition.not_well_formed, error.getCondition());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -27,11 +27,11 @@ import org.jivesoftware.smack.provider.ExtensionElementProvider;
|
|||
import org.jivesoftware.smack.provider.ProviderManager;
|
||||
import org.jivesoftware.smack.test.util.TestUtils;
|
||||
import org.jivesoftware.smack.util.PacketParserUtils;
|
||||
import org.jivesoftware.smack.xml.XmlPullParser;
|
||||
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
|
||||
public class ParsingExceptionTest {
|
||||
|
||||
|
|
@ -39,6 +39,7 @@ public class ParsingExceptionTest {
|
|||
"<extension2 xmlns='namespace'>" +
|
||||
"<bar node='testNode'>" +
|
||||
"<i id='testid1'>" +
|
||||
"text content" +
|
||||
"</i>" +
|
||||
"</bar>" +
|
||||
"</extension2>";
|
||||
|
|
@ -57,8 +58,7 @@ public class ParsingExceptionTest {
|
|||
public void consumeUnparsedInput() throws Exception {
|
||||
final String MESSAGE_EXCEPTION_ELEMENT =
|
||||
"<" + ThrowException.ELEMENT + " xmlns='" + ThrowException.NAMESPACE + "'>" +
|
||||
"<nothingInHere>" +
|
||||
"</nothingInHere>" +
|
||||
"<nothingInHere/>" +
|
||||
"</" + ThrowException.ELEMENT + ">";
|
||||
XmlPullParser parser = TestUtils.getMessageParser(
|
||||
"<message from='user@server.example' to='francisco@denmark.lit' id='foo'>" +
|
||||
|
|
|
|||
|
|
@ -22,10 +22,10 @@ import java.util.Collection;
|
|||
import org.jivesoftware.smack.packet.IQ;
|
||||
import org.jivesoftware.smack.packet.XmlEnvironment;
|
||||
import org.jivesoftware.smack.util.FileUtils;
|
||||
import org.jivesoftware.smack.xml.XmlPullParser;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
|
||||
public class ProviderConfigTest {
|
||||
|
||||
|
|
|
|||
|
|
@ -21,9 +21,9 @@ import static org.junit.Assert.assertTrue;
|
|||
import org.jivesoftware.smack.SmackConfiguration;
|
||||
import org.jivesoftware.smack.packet.IQ;
|
||||
import org.jivesoftware.smack.packet.XmlEnvironment;
|
||||
import org.jivesoftware.smack.xml.XmlPullParser;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
|
||||
public class ProviderManagerTest {
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright © 2014-2017 Florian Schmaus
|
||||
* Copyright © 2014-2019 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -16,8 +16,8 @@
|
|||
*/
|
||||
package org.jivesoftware.smack.sasl;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.util.HashMap;
|
||||
|
|
|
|||
|
|
@ -0,0 +1,165 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2019 Florian Schmaus
|
||||
*
|
||||
* 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.util;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.io.Reader;
|
||||
import java.io.StringReader;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
import javax.xml.namespace.QName;
|
||||
|
||||
import org.jivesoftware.smack.packet.Element;
|
||||
import org.jivesoftware.smack.parsing.SmackParsingException;
|
||||
import org.jivesoftware.smack.provider.Provider;
|
||||
import org.jivesoftware.smack.xml.XmlPullParser;
|
||||
import org.jivesoftware.smack.xml.XmlPullParserException;
|
||||
import org.jivesoftware.smack.xml.XmlPullParserFactory;
|
||||
import org.jivesoftware.smack.xml.stax.StaxXmlPullParserFactory;
|
||||
import org.jivesoftware.smack.xml.xpp3.Xpp3XmlPullParserFactory;
|
||||
|
||||
public class SmackTestUtil {
|
||||
|
||||
@SuppressWarnings("ImmutableEnumChecker")
|
||||
public enum XmlPullParserKind {
|
||||
StAX(StaxXmlPullParserFactory.class),
|
||||
XPP3(Xpp3XmlPullParserFactory.class),
|
||||
;
|
||||
|
||||
public final XmlPullParserFactory factory;
|
||||
|
||||
XmlPullParserKind(Class<? extends XmlPullParserFactory> factoryClass) {
|
||||
try {
|
||||
factory = factoryClass.getDeclaredConstructor().newInstance();
|
||||
}
|
||||
catch (InstantiationException | IllegalAccessException | IllegalArgumentException
|
||||
| InvocationTargetException | NoSuchMethodException | SecurityException e) {
|
||||
throw new AssertionError(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static <E extends Element, P extends Provider<E>> E parse(CharSequence xml, Class<P> providerClass, XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
P provider = providerClassToProvider(providerClass);
|
||||
return parse(xml, provider, parserKind);
|
||||
}
|
||||
|
||||
public static <E extends Element, P extends Provider<E>> E parse(InputStream inputStream, Class<P> providerClass, XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
P provider = providerClassToProvider(providerClass);
|
||||
return parse(inputStream, provider, parserKind);
|
||||
}
|
||||
|
||||
public static <E extends Element, P extends Provider<E>> E parse(Reader reader, Class<P> providerClass, XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
P provider = providerClassToProvider(providerClass);
|
||||
return parse(reader, provider, parserKind);
|
||||
}
|
||||
|
||||
public static <E extends Element> E parse(CharSequence xml, Provider<E> provider, XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
String xmlString = xml.toString();
|
||||
Reader reader = new StringReader(xmlString);
|
||||
return parse(reader, provider, parserKind);
|
||||
}
|
||||
|
||||
public static <E extends Element> E parse(InputStream inputStream, Provider<E> provider, XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
|
||||
return parse(inputStreamReader, provider, parserKind);
|
||||
}
|
||||
|
||||
public static <E extends Element> E parse(Reader reader, Provider<E> provider, XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException, SmackParsingException {
|
||||
XmlPullParser parser = getParserFor(reader, parserKind);
|
||||
E element = provider.parse(parser);
|
||||
return element;
|
||||
}
|
||||
|
||||
public static XmlPullParser getParserFor(String xml, XmlPullParserKind parserKind) throws XmlPullParserException, IOException {
|
||||
Reader reader = new StringReader(xml);
|
||||
return getParserFor(reader, parserKind);
|
||||
}
|
||||
|
||||
public static XmlPullParser getParserFor(InputStream inputStream, XmlPullParserKind parserKind) throws XmlPullParserException, IOException {
|
||||
InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
|
||||
return getParserFor(inputStreamReader, parserKind);
|
||||
}
|
||||
|
||||
public static XmlPullParser getParserFor(Reader reader, XmlPullParserKind parserKind) throws XmlPullParserException, IOException {
|
||||
XmlPullParser parser = parserKind.factory.newXmlPullParser(reader);
|
||||
forwardParserToStartElement(parser);
|
||||
return parser;
|
||||
}
|
||||
|
||||
public static XmlPullParser getParserFor(String xml, QName startTagQName, XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
XmlPullParser parser = getParserFor(xml, parserKind);
|
||||
forwardParserToStartElement(parser, (p) -> p.getQName().equals(startTagQName));
|
||||
return parser;
|
||||
}
|
||||
|
||||
public static XmlPullParser getParserFor(String xml, String startTagLocalpart, XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
XmlPullParser parser = getParserFor(xml, parserKind);
|
||||
forwardParserToStartElement(parser, (p) -> p.getName().equals(startTagLocalpart));
|
||||
return parser;
|
||||
}
|
||||
|
||||
private static <E extends Element, P extends Provider<E>> P providerClassToProvider(Class<P> providerClass) {
|
||||
P provider;
|
||||
// TODO: Consider adding a shortcut in case there is a static INSTANCE field holding an instance of the
|
||||
// requested provider.
|
||||
try {
|
||||
provider = providerClass.getDeclaredConstructor().newInstance();
|
||||
}
|
||||
catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
|
||||
| NoSuchMethodException | SecurityException e) {
|
||||
throw new AssertionError(e);
|
||||
}
|
||||
return provider;
|
||||
}
|
||||
|
||||
private static void forwardParserToStartElement(XmlPullParser parser) throws XmlPullParserException, IOException {
|
||||
forwardParserToStartElement(parser, p -> true);
|
||||
}
|
||||
|
||||
private static void forwardParserToStartElement(XmlPullParser parser,
|
||||
Predicate<XmlPullParser> doneForwarding) throws XmlPullParserException, IOException {
|
||||
outerloop: while (true) {
|
||||
XmlPullParser.Event event = parser.getEventType();
|
||||
switch (event) {
|
||||
case START_ELEMENT:
|
||||
if (doneForwarding.test(parser)) {
|
||||
break outerloop;
|
||||
}
|
||||
break;
|
||||
case END_DOCUMENT:
|
||||
throw new IllegalArgumentException("Not matching START_ELEMENT found");
|
||||
default:
|
||||
// Catch all for incomplete switch (MissingCasesInEnumSwitch) statement.
|
||||
break;
|
||||
}
|
||||
parser.next();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -20,14 +20,11 @@ import java.io.IOException;
|
|||
import java.io.Reader;
|
||||
import java.io.StringReader;
|
||||
|
||||
import org.jivesoftware.smack.packet.ExtensionElement;
|
||||
import org.jivesoftware.smack.packet.XmlEnvironment;
|
||||
import org.jivesoftware.smack.util.PacketParserUtils;
|
||||
import org.jivesoftware.smack.util.ParserUtils;
|
||||
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
import org.xmlpull.v1.XmlPullParserException;
|
||||
import org.jivesoftware.smack.xml.SmackXmlParser;
|
||||
import org.jivesoftware.smack.xml.XmlPullParser;
|
||||
import org.jivesoftware.smack.xml.XmlPullParserException;
|
||||
|
||||
// TODO: Remove this class and replace it with SmackTestUtil.
|
||||
public final class TestUtils {
|
||||
private TestUtils() {
|
||||
}
|
||||
|
|
@ -52,12 +49,12 @@ public final class TestUtils {
|
|||
return getParser(new StringReader(string), startTag);
|
||||
}
|
||||
|
||||
public static XmlPullParser getParser(Reader reader, String startTag) {
|
||||
private static XmlPullParser getParser(Reader reader, String startTag) {
|
||||
XmlPullParser parser;
|
||||
try {
|
||||
parser = PacketParserUtils.newXmppParser(reader);
|
||||
parser = SmackXmlParser.newXmlParser(reader);
|
||||
if (startTag == null) {
|
||||
while (parser.getEventType() != XmlPullParser.START_TAG) {
|
||||
while (parser.getEventType() != XmlPullParser.Event.START_ELEMENT) {
|
||||
parser.next();
|
||||
}
|
||||
return parser;
|
||||
|
|
@ -65,7 +62,7 @@ public final class TestUtils {
|
|||
boolean found = false;
|
||||
|
||||
while (!found) {
|
||||
if ((parser.next() == XmlPullParser.START_TAG) && parser.getName().equals(startTag))
|
||||
if ((parser.next() == XmlPullParser.Event.START_ELEMENT) && parser.getName().equals(startTag))
|
||||
found = true;
|
||||
}
|
||||
|
||||
|
|
@ -79,17 +76,4 @@ public final class TestUtils {
|
|||
return parser;
|
||||
}
|
||||
|
||||
public static <EE extends ExtensionElement> EE parseExtensionElement(String elementString)
|
||||
throws Exception {
|
||||
return parseExtensionElement(getParser(elementString), null);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <EE extends ExtensionElement> EE parseExtensionElement(XmlPullParser parser, XmlEnvironment outerXmlEnvironment)
|
||||
throws Exception {
|
||||
ParserUtils.assertAtStartTag(parser);
|
||||
final String elementName = parser.getName();
|
||||
final String namespace = parser.getNamespace();
|
||||
return (EE) PacketParserUtils.parseExtensionElement(elementName, namespace, parser, outerXmlEnvironment);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -29,6 +29,8 @@ import java.util.HashMap;
|
|||
import java.util.Locale;
|
||||
import java.util.Map;
|
||||
import java.util.Properties;
|
||||
import java.util.function.Supplier;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import javax.xml.parsers.FactoryConfigurationError;
|
||||
import javax.xml.parsers.ParserConfigurationException;
|
||||
|
|
@ -42,15 +44,18 @@ import org.jivesoftware.smack.packet.StreamOpen;
|
|||
import org.jivesoftware.smack.sasl.SASLError;
|
||||
import org.jivesoftware.smack.sasl.packet.SaslStreamElements;
|
||||
import org.jivesoftware.smack.sasl.packet.SaslStreamElements.SASLFailure;
|
||||
import org.jivesoftware.smack.test.util.SmackTestUtil;
|
||||
import org.jivesoftware.smack.test.util.TestUtils;
|
||||
import org.jivesoftware.smack.test.util.XmlUnitUtils;
|
||||
import org.jivesoftware.smack.xml.XmlPullParser;
|
||||
import org.jivesoftware.smack.xml.XmlPullParserException;
|
||||
|
||||
import com.jamesmurty.utils.XMLBuilder;
|
||||
import org.junit.Ignore;
|
||||
import org.junit.Test;
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.EnumSource;
|
||||
import org.xml.sax.SAXException;
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
import org.xmlpull.v1.XmlPullParserException;
|
||||
|
||||
public class PacketParserUtilsTest {
|
||||
|
||||
|
|
@ -59,8 +64,9 @@ public class PacketParserUtilsTest {
|
|||
outputProperties.put(javax.xml.transform.OutputKeys.OMIT_XML_DECLARATION, "yes");
|
||||
}
|
||||
|
||||
@Test
|
||||
public void singleMessageBodyTest() throws Exception {
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void singleMessageBodyTest(SmackTestUtil.XmlPullParserKind parserKind) throws Exception {
|
||||
String defaultLanguage = Stanza.getDefaultLanguage();
|
||||
String otherLanguage = determineNonDefaultLanguage();
|
||||
|
||||
|
|
@ -79,7 +85,7 @@ public class PacketParserUtilsTest {
|
|||
.asString(outputProperties);
|
||||
|
||||
Message message = PacketParserUtils
|
||||
.parseMessage(PacketParserUtils.getParserFor(control));
|
||||
.parseMessage(SmackTestUtil.getParserFor(control, parserKind));
|
||||
|
||||
assertEquals(defaultLanguage, message.getBody());
|
||||
assertTrue(message.getBodyLanguages().isEmpty());
|
||||
|
|
@ -99,7 +105,7 @@ public class PacketParserUtilsTest {
|
|||
.t(otherLanguage)
|
||||
.asString(outputProperties);
|
||||
|
||||
message = PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(control));
|
||||
message = PacketParserUtils.parseMessage(SmackTestUtil.getParserFor(control, parserKind));
|
||||
|
||||
assertEquals(otherLanguage, message.getBody());
|
||||
assertTrue(message.getBodyLanguages().isEmpty());
|
||||
|
|
@ -118,7 +124,7 @@ public class PacketParserUtilsTest {
|
|||
.t(defaultLanguage)
|
||||
.asString(outputProperties);
|
||||
|
||||
message = PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(control));
|
||||
message = PacketParserUtils.parseMessage(SmackTestUtil.getParserFor(control, parserKind));
|
||||
|
||||
assertEquals(defaultLanguage, message.getBody());
|
||||
assertTrue(message.getBodyLanguages().isEmpty());
|
||||
|
|
@ -138,7 +144,7 @@ public class PacketParserUtilsTest {
|
|||
.t(defaultLanguage)
|
||||
.asString(outputProperties);
|
||||
|
||||
message = PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(control));
|
||||
message = PacketParserUtils.parseMessage(SmackTestUtil.getParserFor(control, parserKind));
|
||||
|
||||
assertNull(message.getBody());
|
||||
assertFalse(message.getBodyLanguages().isEmpty());
|
||||
|
|
@ -159,7 +165,7 @@ public class PacketParserUtilsTest {
|
|||
.t(otherLanguage)
|
||||
.asString(outputProperties);
|
||||
|
||||
message = PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(control));
|
||||
message = PacketParserUtils.parseMessage(SmackTestUtil.getParserFor(control, parserKind));
|
||||
|
||||
assertNull(message.getBody());
|
||||
assertFalse(message.getBodyLanguages().isEmpty());
|
||||
|
|
@ -181,7 +187,7 @@ public class PacketParserUtilsTest {
|
|||
.t(otherLanguage)
|
||||
.asString(outputProperties);
|
||||
|
||||
message = PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(control));
|
||||
message = PacketParserUtils.parseMessage(SmackTestUtil.getParserFor(control, parserKind));
|
||||
|
||||
assertNull(message.getBody());
|
||||
assertFalse(message.getBodyLanguages().isEmpty());
|
||||
|
|
@ -203,7 +209,7 @@ public class PacketParserUtilsTest {
|
|||
.t(defaultLanguage)
|
||||
.asString(outputProperties);
|
||||
|
||||
message = PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(control));
|
||||
message = PacketParserUtils.parseMessage(SmackTestUtil.getParserFor(control, parserKind));
|
||||
|
||||
assertNull(message.getBody());
|
||||
assertFalse(message.getBodyLanguages().isEmpty());
|
||||
|
|
@ -708,13 +714,18 @@ public class PacketParserUtilsTest {
|
|||
.t("Good Message Body")
|
||||
.asString(outputProperties);
|
||||
|
||||
// XPP3 writes "end tag", StAX writes "end-tag".
|
||||
Supplier<Stream<String>> expectedContentOfExceptionMessage = () -> Stream.of("end tag", "end-tag");
|
||||
|
||||
String invalidControl = validControl.replace("Good Message Body", "Bad </span> Body");
|
||||
|
||||
try {
|
||||
PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(invalidControl));
|
||||
fail("Exception should be thrown");
|
||||
} catch (XmlPullParserException e) {
|
||||
assertTrue(e.getMessage().contains("end tag name </span>"));
|
||||
String exceptionMessage = e.getMessage();
|
||||
boolean expectedContentFound = expectedContentOfExceptionMessage.get().anyMatch((expected) -> exceptionMessage.contains(expected));
|
||||
assertTrue(expectedContentFound);
|
||||
}
|
||||
|
||||
invalidControl = validControl.replace("Good Message Body", "Bad </body> Body");
|
||||
|
|
@ -723,7 +734,9 @@ public class PacketParserUtilsTest {
|
|||
PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(invalidControl));
|
||||
fail("Exception should be thrown");
|
||||
} catch (XmlPullParserException e) {
|
||||
assertTrue(e.getMessage().contains("end tag name </body>"));
|
||||
String exceptionMessage = e.getMessage();
|
||||
boolean expectedContentFound = expectedContentOfExceptionMessage.get().anyMatch((expected) -> exceptionMessage.contains(expected));
|
||||
assertTrue(expectedContentFound);
|
||||
}
|
||||
|
||||
invalidControl = validControl.replace("Good Message Body", "Bad </message> Body");
|
||||
|
|
@ -732,9 +745,10 @@ public class PacketParserUtilsTest {
|
|||
PacketParserUtils.parseMessage(PacketParserUtils.getParserFor(invalidControl));
|
||||
fail("Exception should be thrown");
|
||||
} catch (XmlPullParserException e) {
|
||||
assertTrue(e.getMessage().contains("end tag name </message>"));
|
||||
String exceptionMessage = e.getMessage();
|
||||
boolean expectedContentFound = expectedContentOfExceptionMessage.get().anyMatch((expected) -> exceptionMessage.contains(expected));
|
||||
assertTrue(expectedContentFound);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
|
|
@ -808,13 +822,13 @@ public class PacketParserUtilsTest {
|
|||
// CHECKSTYLE:ON
|
||||
}
|
||||
|
||||
@Test
|
||||
public void parseContentDepthTest() throws Exception {
|
||||
final String stanza = "<iq type='result' to='foo@bar.com' from='baz.com' id='42'/>";
|
||||
XmlPullParser parser = TestUtils.getParser(stanza, "iq");
|
||||
CharSequence content = PacketParserUtils.parseContent(parser);
|
||||
assertEquals("", content.toString());
|
||||
}
|
||||
// @Test
|
||||
// public void parseContentDepthTest() throws Exception {
|
||||
// final String stanza = "<iq type='result' to='foo@bar.com' from='baz.com' id='42'/>";
|
||||
// XmlPullParser parser = TestUtils.getParser(stanza, "iq");
|
||||
// CharSequence content = PacketParserUtils.parseContent(parser);
|
||||
// assertEquals("", content.toString());
|
||||
// }
|
||||
|
||||
@Test
|
||||
public void parseElementMultipleNamespace()
|
||||
|
|
|
|||
|
|
@ -0,0 +1,231 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2019 Florian Schmaus
|
||||
*
|
||||
* 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.xml;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.Reader;
|
||||
import java.io.StringReader;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import javax.xml.XMLConstants;
|
||||
import javax.xml.namespace.QName;
|
||||
|
||||
import org.jivesoftware.smack.test.util.SmackTestUtil;
|
||||
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.EnumSource;
|
||||
|
||||
public class XmlPullParserTest {
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testSimpleEmptyElement(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
Reader reader = new StringReader("<empty-element/>");
|
||||
XmlPullParser parser = parserKind.factory.newXmlPullParser(reader);
|
||||
|
||||
assertEquals(XmlPullParser.Event.START_DOCUMENT, parser.getEventType());
|
||||
assertEquals(XmlPullParser.Event.START_ELEMENT, parser.next());
|
||||
QName qname = parser.getQName();
|
||||
assertEquals(qname.getLocalPart(), "empty-element");
|
||||
assertEquals(qname.getPrefix(), XMLConstants.DEFAULT_NS_PREFIX);
|
||||
assertEquals(qname.getNamespaceURI(), XMLConstants.NULL_NS_URI);
|
||||
assertEquals(XmlPullParser.Event.END_ELEMENT, parser.next());
|
||||
assertEquals(XmlPullParser.Event.END_DOCUMENT, parser.next());
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testQNameSimpleElement(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String simpleElement = "<outer-element xmlns='outer-namespace'><inner-element/></outer-element>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(simpleElement, parserKind);
|
||||
QName qname = parser.getQName();
|
||||
assertEquals("outer-element", qname.getLocalPart());
|
||||
assertEquals("outer-namespace", qname.getNamespaceURI());
|
||||
assertEquals(XmlPullParser.Event.START_ELEMENT, parser.next());
|
||||
qname = parser.getQName();
|
||||
assertEquals("inner-element", qname.getLocalPart());
|
||||
assertEquals("outer-namespace", qname.getNamespaceURI());
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testQNamePrefixElement(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String prefixElement = "<outer-element xmlns='outer-namespace' xmlns:inner-prefix='inner-namespace'><inner-prefix:inner-element></outer-element>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(prefixElement, parserKind);
|
||||
QName qname = parser.getQName();
|
||||
assertEquals("outer-element", qname.getLocalPart());
|
||||
assertEquals("outer-namespace", qname.getNamespaceURI());
|
||||
assertEquals(XmlPullParser.Event.START_ELEMENT, parser.next());
|
||||
qname = parser.getQName();
|
||||
assertEquals("inner-element", qname.getLocalPart());
|
||||
assertEquals("inner-namespace", qname.getNamespaceURI());
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testAttributesElementWithOneAttribute(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String elementWithOneAttribute = "<element attribute-one='attribute-one-value'/>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(elementWithOneAttribute, parserKind);
|
||||
assertAttributeHolds(parser, 0, "attribute-one", "", "");
|
||||
assertThrows(NullPointerException.class, () ->
|
||||
assertAttributeHolds(parser, 1, "attribute-one", "", ""));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testAttributesNamespacedElementWithOneAttribute(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String namespacedElementWithOneAttribute = "<element xmlns='element-namespace' attribute-one='attribute-one-value'/>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(namespacedElementWithOneAttribute, parserKind);
|
||||
assertAttributeHolds(parser, 0, "attribute-one", "", "");
|
||||
assertThrows(NullPointerException.class, () ->
|
||||
assertAttributeHolds(parser, 1, "attribute-one", "", ""));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testAttributesNamespacedElementWithOneNamespacedAttribute(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String namespacedElementWithOneNamespacedAttribute = "<element xmlns='element-namespace' xmlns:attribute-namespace='attribute-namespace-value' attribute-namespace:attribute-one='attribute-one-value'/>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(namespacedElementWithOneNamespacedAttribute, parserKind);
|
||||
assertAttributeHolds(parser, 0, "attribute-one", "attribute-namespace", "attribute-namespace-value");
|
||||
assertThrows(NullPointerException.class, () ->
|
||||
assertAttributeHolds(parser, 1, "attribute-one", "", ""));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testNamespacedAttributes(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String element = "<element xmlns:attr='attribute-namespace' attr:attributeOneName='attributeOneValue'/>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(element, parserKind);
|
||||
assertEquals(1, parser.getAttributeCount());
|
||||
|
||||
assertEquals("attributeOneName", parser.getAttributeName(0));
|
||||
assertEquals("attr", parser.getAttributePrefix(0));
|
||||
assertEquals("attribute-namespace", parser.getAttributeNamespace(0));
|
||||
QName attributeZeroQname = parser.getAttributeQName(0);
|
||||
assertEquals("attributeOneName", attributeZeroQname.getLocalPart());
|
||||
assertEquals("attr", attributeZeroQname.getPrefix());
|
||||
assertEquals("attribute-namespace", attributeZeroQname.getNamespaceURI());
|
||||
|
||||
// Test how parser handle non-existent attributes.
|
||||
assertNull(parser.getAttributeName(1));
|
||||
assertNull(parser.getAttributePrefix(1));
|
||||
assertNull(parser.getAttributeNamespace(1));
|
||||
QName attributeOneQname = parser.getAttributeQName(1);
|
||||
assertNull(attributeOneQname);
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testAttributeType(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String element = "<element xmlns:attr='attribute-namespace' attr:attributeOneName='attributeOneValue'/>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(element, parserKind);
|
||||
|
||||
assertEquals("CDATA", parser.getAttributeType(0));
|
||||
|
||||
assertNull(parser.getAttributeType(1));
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testNextText(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
XmlPullParser parser;
|
||||
|
||||
String simpleElement = "<element>Element text</element>";
|
||||
parser = SmackTestUtil.getParserFor(simpleElement, parserKind);
|
||||
assertEquals("Element text", parser.nextText());
|
||||
|
||||
String complexElement = "<outer-elment><element1>Element 1 ' text</element1><element2>Element 2 text</element2></outer-element>";
|
||||
parser = SmackTestUtil.getParserFor(complexElement, parserKind);
|
||||
assertEquals(XmlPullParser.Event.START_ELEMENT, parser.next());
|
||||
assertEquals("element1", parser.getName());
|
||||
assertEquals(0, parser.getAttributeCount());
|
||||
assertEquals("Element 1 ' text", parser.nextText());
|
||||
|
||||
assertEquals(XmlPullParser.Event.START_ELEMENT, parser.next());
|
||||
assertEquals("element2", parser.getName());
|
||||
assertEquals(0, parser.getAttributeCount());
|
||||
assertEquals("Element 2 text", parser.nextText());
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testNextTextMixedContent(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String element = "<element>Mixed content element text<inner-element>Inner element text</inner-element></element>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(element, parserKind);
|
||||
assertThrows(XmlPullParserException.class, () -> parser.nextText());
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testNextTextOnEndElement(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String element = "<element>Element text</element>";
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(element, parserKind);
|
||||
assertEquals(XmlPullParser.Event.START_ELEMENT, parser.getEventType());
|
||||
assertEquals(XmlPullParser.Event.TEXT_CHARACTERS, parser.next());
|
||||
assertEquals(XmlPullParser.Event.END_ELEMENT, parser.next());
|
||||
assertThrows(XmlPullParserException.class, () -> parser.nextText());
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@EnumSource(SmackTestUtil.XmlPullParserKind.class)
|
||||
public void testNextTextOnEmptyElement(SmackTestUtil.XmlPullParserKind parserKind)
|
||||
throws XmlPullParserException, IOException {
|
||||
String[] emptyElementStream = Stream.of().toArray(String[]::new);
|
||||
for (String emptyElement : emptyElementStream) {
|
||||
XmlPullParser parser = SmackTestUtil.getParserFor(emptyElement, parserKind);
|
||||
assertEquals(XmlPullParser.Event.START_ELEMENT, parser.getEventType());
|
||||
assertEquals("", parser.nextText());
|
||||
}
|
||||
}
|
||||
|
||||
private static void assertAttributeHolds(XmlPullParser parser, int attributeIndex, String expectedLocalpart,
|
||||
String expectedPrefix, String expectedNamespace) {
|
||||
QName qname = parser.getAttributeQName(attributeIndex);
|
||||
String qnameNamespaceUri = qname.getNamespaceURI();
|
||||
|
||||
assertEquals(expectedLocalpart, qname.getLocalPart());
|
||||
assertEquals(expectedPrefix, qname.getPrefix());
|
||||
assertEquals(expectedNamespace, qnameNamespaceUri);
|
||||
|
||||
assertEquals(qname.getLocalPart(), parser.getAttributeName(attributeIndex));
|
||||
assertEquals(qname.getPrefix(), parser.getAttributePrefix(attributeIndex));
|
||||
|
||||
final String expectedGetAttributeNamespace;
|
||||
if (qnameNamespaceUri.equals(XMLConstants.NULL_NS_URI)) {
|
||||
expectedGetAttributeNamespace = null;
|
||||
}
|
||||
else {
|
||||
expectedGetAttributeNamespace = qnameNamespaceUri;
|
||||
}
|
||||
assertEquals(expectedGetAttributeNamespace, parser.getAttributeNamespace(attributeIndex));
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue