Merge pull request #368 from vanitasvitae/fallbackIndication

XEP-0428: Fallback Indication

build.gradle

@@ -116,6 +116,7 @@ allprojects {
 		].collect { project(it) }
 		junitVersion = '5.6.0'
 		commonsIoVersion = '2.6'
+		bouncyCastleVersion = '1.65'
 		if (project.hasProperty("useSonatype")) {
 			useSonatype = project.getProperty("useSonatype").toBoolean()
 		} else {

documentation/connection-modules.md

@@ -5,7 +5,7 @@ Smack's Modular Connection Architecture
 
 **Note: Everything related to the modular connection architecture is currently considered experimental and should not be used in production. Use the mature `XMPPTCPConnection` if you do not feel adventurous.
 
-Smack's modular connection architecture allows to extend a XMPP c2s (client-to-server) connection with additional functionalty by adding modules.
+Smack's modular connection architecture allows to extend a XMPP c2s (client-to-server) connection with additional functionality by adding modules.
 Those modules extend the Finite State Machine (FSM) within the `ModularXmppClientToServerConnection` with new states.
 
 Connection modules can either be
@@ -32,4 +32,4 @@ Connection modules are plugged into the the modular connection via their constru
 
 Modules and states always have an accompanying *descriptor* type.
 `ModuleDescriptor` and `StateDescriptor` exist without an connection instance.
-They describe the module and state metadata, while their modules are states are instanciated once a modular connection is instanciated.
+They describe the module and state metadata, while their modules and states are instanciated once a modular connection is instanciated.

documentation/extensions/index.md

@@ -122,6 +122,7 @@ Experimental Smack Extensions and currently supported XEPs of smack-experimental
 | [Message Markup](messagemarkup.md)                        | [XEP-0394](https://xmpp.org/extensions/xep-0394.html)  | 0.1.0     | Style message bodies while keeping body and markup information separated. |
 | DNS Queries over XMPP (DoX)                               | [XEP-0418](https://xmpp.org/extensions/xep-0418.html)  | 0.1.0     | Send DNS queries and responses over XMPP. |
 | Message Fastening                                         | [XEP-0422](https://xmpp.org/extensions/xep-0422.html)  | 0.1.1     | Mark payloads on a message to be logistically fastened to a previous message. |
+| Fallback Indication                                       | [XEP-0428](https://xmpp.org/extensions/xep-0428.html)  | 0.1.0     | Declare body elements of a message as ignorable fallback for naive legacy clients. |
 
 Unofficial XMPP Extensions
 --------------------------

smack-core/build.gradle

@@ -18,7 +18,7 @@ dependencies {
 	// 'implementation' here since there is no need to shadow it
 	// outside of the fixtures compilation classpath. That is, no test
 	// should ever setup Bouncy Castle as security provider explicitly.
-	testFixturesImplementation 'org.bouncycastle:bcprov-jdk15on:1.64'
+	testFixturesImplementation "org.bouncycastle:bcprov-jdk15on:${bouncyCastleVersion}"
 	testFixturesImplementation 'org.apache.commons:commons-lang3:3.10'
 
 	testFixturesApi "org.jxmpp:jxmpp-jid:$jxmppVersion:tests"

smack-core/src/main/java/org/jivesoftware/smack/packet/Stanza.java

@@ -380,7 +380,7 @@ public abstract class Stanza implements StanzaView, TopLevelStreamElement {
      * @param elementName the XML element name of the extension. (May be null)
      * @param namespace the XML element namespace of the extension.
      * @return the extension, or <code>null</code> if it doesn't exist.
-     * @deprecated use {@link #getExtension(Class)} or {@link #getExtensionElement(String, String)} isntead.
+     * @deprecated use {@link #getExtension(Class)} or {@link #getExtensionElement(String, String)} instead.
      */
     // TODO: Remove in Smack 4.5.
     @SuppressWarnings("unchecked")

smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationListener.java

@@ -0,0 +1,33 @@
+/**
+ *
+ * Copyright 2020 Paul Schaub
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smackx.fallback_indication;
+
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smackx.fallback_indication.element.FallbackIndicationElement;
+
+public interface FallbackIndicationListener {
+
+    /**
+     * Listener method that gets called when a {@link Message} containing a {@link FallbackIndicationElement} is received.
+     *
+     * @param message message
+     * @param indicator Fallback Indication
+     * @param fallbackBody body that is marked as fallback
+     */
+    void onFallbackIndicationReceived(Message message, FallbackIndicationElement indicator, String fallbackBody);
+
+}

smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationManager.java

@@ -0,0 +1,174 @@
+/**
+ *
+ * Copyright 2020 Paul Schaub
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smackx.fallback_indication;
+
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+import org.jivesoftware.smack.AsyncButOrdered;
+import org.jivesoftware.smack.ConnectionCreationListener;
+import org.jivesoftware.smack.Manager;
+import org.jivesoftware.smack.SmackException;
+import org.jivesoftware.smack.StanzaListener;
+import org.jivesoftware.smack.XMPPConnection;
+import org.jivesoftware.smack.XMPPConnectionRegistry;
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.filter.AndFilter;
+import org.jivesoftware.smack.filter.StanzaExtensionFilter;
+import org.jivesoftware.smack.filter.StanzaFilter;
+import org.jivesoftware.smack.filter.StanzaTypeFilter;
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.packet.MessageBuilder;
+import org.jivesoftware.smack.packet.Stanza;
+import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
+import org.jivesoftware.smackx.fallback_indication.element.FallbackIndicationElement;
+
+import org.jxmpp.jid.BareJid;
+import org.jxmpp.jid.EntityBareJid;
+
+/**
+ * Smacks API for XEP-0428: Fallback Indication.
+ * In some scenarios it might make sense to mark the body of a message as fallback for legacy clients.
+ * Examples are encryption mechanisms where the sender might include a hint for legacy clients stating that the
+ * body (eg. "This message is encrypted") should be ignored.
+ *
+ * @see <a href="https://xmpp.org/extensions/xep-0428.html">XEP-0428: Fallback Indication</a>
+ */
+public final class FallbackIndicationManager extends Manager {
+
+    private static final Map<XMPPConnection, FallbackIndicationManager> INSTANCES = new WeakHashMap<>();
+
+    static {
+        XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
+            @Override
+            public void connectionCreated(XMPPConnection connection) {
+                getInstanceFor(connection);
+            }
+        });
+    }
+
+    private final Set<FallbackIndicationListener> listeners = new CopyOnWriteArraySet<>();
+    private final AsyncButOrdered<BareJid> asyncButOrdered = new AsyncButOrdered<>();
+    private final StanzaFilter fallbackIndicationElementFilter = new AndFilter(StanzaTypeFilter.MESSAGE,
+            new StanzaExtensionFilter(FallbackIndicationElement.ELEMENT, FallbackIndicationElement.NAMESPACE));
+
+    private final StanzaListener fallbackIndicationElementListener = new StanzaListener() {
+        @Override
+        public void processStanza(Stanza packet) {
+            Message message = (Message) packet;
+            FallbackIndicationElement indicator = FallbackIndicationElement.fromMessage(message);
+            String body = message.getBody();
+            asyncButOrdered.performAsyncButOrdered(message.getFrom().asBareJid(), () -> {
+                for (FallbackIndicationListener l : listeners) {
+                    l.onFallbackIndicationReceived(message, indicator, body);
+                }
+            });
+        }
+    };
+
+    private FallbackIndicationManager(XMPPConnection connection) {
+        super(connection);
+        connection.addAsyncStanzaListener(fallbackIndicationElementListener, fallbackIndicationElementFilter);
+        ServiceDiscoveryManager.getInstanceFor(connection).addFeature(FallbackIndicationElement.NAMESPACE);
+    }
+
+    public static synchronized FallbackIndicationManager getInstanceFor(XMPPConnection connection) {
+        FallbackIndicationManager manager = INSTANCES.get(connection);
+        if (manager == null) {
+            manager = new FallbackIndicationManager(connection);
+            INSTANCES.put(connection, manager);
+        }
+        return manager;
+    }
+
+    /**
+     * Determine, whether or not a user supports Fallback Indications.
+     *
+     * @param jid BareJid of the user.
+     * @return feature support
+     *
+     * @throws XMPPException.XMPPErrorException if a protocol level error happens
+     * @throws SmackException.NotConnectedException if the connection is not connected
+     * @throws InterruptedException if the thread is being interrupted
+     * @throws SmackException.NoResponseException if the server doesn't send a response in time
+     */
+    public boolean userSupportsFallbackIndications(EntityBareJid jid)
+            throws XMPPException.XMPPErrorException, SmackException.NotConnectedException, InterruptedException,
+            SmackException.NoResponseException {
+        return ServiceDiscoveryManager.getInstanceFor(connection())
+                .supportsFeature(jid, FallbackIndicationElement.NAMESPACE);
+    }
+
+    /**
+     * Determine, whether or not the server supports Fallback Indications.
+     *
+     * @return server side feature support
+     *
+     * @throws XMPPException.XMPPErrorException if a protocol level error happens
+     * @throws SmackException.NotConnectedException if the connection is not connected
+     * @throws InterruptedException if the thread is being interrupted
+     * @throws SmackException.NoResponseException if the server doesn't send a response in time
+     */
+    public boolean serverSupportsFallbackIndications()
+            throws XMPPException.XMPPErrorException, SmackException.NotConnectedException, InterruptedException,
+            SmackException.NoResponseException {
+        return ServiceDiscoveryManager.getInstanceFor(connection())
+                .serverSupportsFeature(FallbackIndicationElement.NAMESPACE);
+    }
+
+    /**
+     * Set the body of the message to the provided fallback message and add a {@link FallbackIndicationElement}.
+     *
+     * @param messageBuilder message builder
+     * @param fallbackMessageBody fallback message body
+     * @return builder with set body and added fallback element
+     */
+    public MessageBuilder addFallbackIndicationWithBody(MessageBuilder messageBuilder, String fallbackMessageBody) {
+        return addFallbackIndication(messageBuilder).setBody(fallbackMessageBody);
+    }
+
+    /**
+     * Add a {@link FallbackIndicationElement} to the provided message builder.
+     *
+     * @param messageBuilder message builder
+     * @return message builder with added fallback element
+     */
+    public MessageBuilder addFallbackIndication(MessageBuilder messageBuilder) {
+        return messageBuilder.addExtension(new FallbackIndicationElement());
+    }
+
+    /**
+     * Register a {@link FallbackIndicationListener} that gets notified whenever a message that contains a
+     * {@link FallbackIndicationElement} is received.
+     *
+     * @param listener listener to be registered.
+     */
+    public synchronized void addFallbackIndicationListener(FallbackIndicationListener listener) {
+        listeners.add(listener);
+    }
+
+    /**
+     * Unregister a {@link FallbackIndicationListener}.
+     *
+     * @param listener listener to be unregistered.
+     */
+    public synchronized void removeFallbackIndicationListener(FallbackIndicationListener listener) {
+        listeners.remove(listener);
+    }
+}

smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/FallbackIndicationElement.java

@@ -0,0 +1,53 @@
+/**
+ *
+ * Copyright 2020 Paul Schaub
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smackx.fallback_indication.element;
+
+import org.jivesoftware.smack.packet.ExtensionElement;
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.packet.XmlEnvironment;
+import org.jivesoftware.smack.util.XmlStringBuilder;
+
+public class FallbackIndicationElement implements ExtensionElement {
+
+    public static final String NAMESPACE = "urn:xmpp:fallback:0";
+    public static final String ELEMENT = "fallback";
+
+    public static final FallbackIndicationElement INSTANCE = new FallbackIndicationElement();
+
+    @Override
+    public String getNamespace() {
+        return NAMESPACE;
+    }
+
+    @Override
+    public String getElementName() {
+        return ELEMENT;
+    }
+
+    @Override
+    public XmlStringBuilder toXML(XmlEnvironment xmlEnvironment) {
+        return new XmlStringBuilder(this).closeEmptyElement();
+    }
+
+    public static boolean hasFallbackIndication(Message message) {
+        return message.hasExtension(ELEMENT, NAMESPACE);
+    }
+
+    public static FallbackIndicationElement fromMessage(Message message) {
+        return message.getExtension(FallbackIndicationElement.class);
+    }
+}

smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/element/package-info.java

@@ -1,6 +1,6 @@
 /**
  *
- * Copyright 2020 Florian Schmaus
+ * Copyright 2020 Paul Schaub
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,12 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.jivesoftware.smackx.xdata.form;
 
-import org.jivesoftware.smackx.xdata.FormField;
+/**
-
+ * Smack's API for XEP-0428: Fallback Indication.
-public interface FormWriter {
+ * Extension Elements.
-
+ */
-    void write(FormField field);
+package org.jivesoftware.smackx.fallback_indication.element;
-
-}

smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/package-info.java

@@ -0,0 +1,21 @@
+/**
+ *
+ * Copyright 2020 Paul Schaub
+ *
+ * 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.
+ */
+
+/**
+ * Smack's API for XEP-0428: Fallback Indication.
+ */
+package org.jivesoftware.smackx.fallback_indication;

smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/FallbackIndicationElementProvider.java

@@ -0,0 +1,35 @@
+/**
+ *
+ * Copyright 2020 Paul Schaub
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smackx.fallback_indication.provider;
+
+import java.io.IOException;
+
+import org.jivesoftware.smack.packet.XmlEnvironment;
+import org.jivesoftware.smack.parsing.SmackParsingException;
+import org.jivesoftware.smack.provider.ExtensionElementProvider;
+import org.jivesoftware.smack.xml.XmlPullParser;
+import org.jivesoftware.smack.xml.XmlPullParserException;
+import org.jivesoftware.smackx.fallback_indication.element.FallbackIndicationElement;
+
+public class FallbackIndicationElementProvider extends ExtensionElementProvider<FallbackIndicationElement> {
+
+    @Override
+    public FallbackIndicationElement parse(XmlPullParser parser, int initialDepth, XmlEnvironment xmlEnvironment)
+            throws XmlPullParserException, IOException, SmackParsingException {
+        return FallbackIndicationElement.INSTANCE;
+    }
+}

smack-experimental/src/main/java/org/jivesoftware/smackx/fallback_indication/provider/package-info.java

@@ -0,0 +1,22 @@
+/**
+ *
+ * Copyright 2020 Paul Schaub
+ *
+ * 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.
+ */
+
+/**
+ * Smack's API for XEP-0428: Fallback Indication.
+ * Element Providers.
+ */
+package org.jivesoftware.smackx.fallback_indication.provider;

smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers

@@ -299,6 +299,13 @@
       <className>org.jivesoftware.smackx.message_fastening.provider.FasteningElementProvider</className>
     </extensionProvider>
 
+    <!-- XEP-0428: Fallback Indication -->
+    <extensionProvider>
+      <elementName>fallback</elementName>
+      <namespace>urn:xmpp:fallback:0</namespace>
+      <className>org.jivesoftware.smackx.fallback_indication.provider.FallbackIndicationElementProvider</className>
+    </extensionProvider>
+
     <!-- XEP-xxxx: Multi-User Chat Light -->
     <iqProvider>
         <elementName>query</elementName>

smack-experimental/src/test/java/org/jivesoftware/smackx/fallback_indication/FallbackIndicationTest.java

@@ -0,0 +1,42 @@
+/**
+ *
+ * Copyright 2020 Paul Schaub
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.jivesoftware.smackx.fallback_indication;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import org.jivesoftware.smack.packet.Message;
+import org.jivesoftware.smack.packet.MessageBuilder;
+
+import org.jivesoftware.smackx.fallback_indication.element.FallbackIndicationElement;
+
+import org.junit.jupiter.api.Test;
+
+public class FallbackIndicationTest {
+
+    @Test
+    public void testFallbackIndicationElementFromMessageTest() {
+        Message messageWithoutFallback = MessageBuilder.buildMessage()
+                        .build();
+        assertNull(FallbackIndicationElement.fromMessage(messageWithoutFallback));
+
+        Message messageWithFallback = MessageBuilder.buildMessage()
+                        .addExtension(new FallbackIndicationElement())
+                        .build();
+        assertNotNull(FallbackIndicationElement.fromMessage(messageWithFallback));
+    }
+}

smack-extensions/src/main/java/org/jivesoftware/smackx/pubsub/form/ConfigureFormReader.java

@@ -90,7 +90,7 @@ public interface ConfigureFormReader extends FormReader {
      * @return List of the whitelist
      */
     default List<Jid> getChildrenAssociationWhitelist() {
-        FormField formField = read(ConfigureNodeFields.children_association_whitelist.getFieldName());
+        FormField formField = getField(ConfigureNodeFields.children_association_whitelist.getFieldName());
         if (formField == null) {
             Collections.emptyList();
         }

smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FillableForm.java

@@ -39,7 +39,7 @@ import org.jxmpp.jid.util.JidUtil;
 import org.jxmpp.stringprep.XmppStringprepException;
 import org.jxmpp.util.XmppDateTime;
 
-public class FillableForm extends FilledForm implements FormWriter {
+public class FillableForm extends FilledForm {
 
     private final Set<String> requiredFields;
 
@@ -212,7 +212,6 @@ public class FillableForm extends FilledForm implements FormWriter {
         write(filledFormField);
     }
 
-    @Override
     public final void write(FormField filledFormField) {
         if (filledFormField.getType() == FormField.Type.fixed) {
             throw new IllegalArgumentException();
@@ -244,13 +243,13 @@ public class FillableForm extends FilledForm implements FormWriter {
     }
 
     @Override
-    public FormField read(String fieldName) {
+    public FormField getField(String fieldName) {
         FormField filledField = filledFields.get(fieldName);
         if (filledField != null) {
             return filledField;
         }
 
-        return super.read(fieldName);
+        return super.getField(fieldName);
     }
 
     public DataForm getDataFormToSubmit() {

smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FilledForm.java

@@ -43,7 +43,7 @@ public abstract class FilledForm implements FormReader {
     }
 
     @Override
-    public FormField read(String fieldName) {
+    public FormField getField(String fieldName) {
         return dataForm.getField(fieldName);
     }
 
@@ -74,10 +74,6 @@ public abstract class FilledForm implements FormReader {
         return dataForm.hasField(fieldName);
     }
 
-    public FormField getField(String fieldName) {
-        return dataForm.getField(fieldName);
-    }
-
     protected FormField getFieldOrThrow(String fieldName) {
         FormField formField = getField(fieldName);
         if (formField == null) {

smack-extensions/src/main/java/org/jivesoftware/smackx/xdata/form/FormReader.java

@@ -30,10 +30,10 @@ import org.jxmpp.util.XmppDateTime;
 
 public interface FormReader {
 
-    FormField read(String fieldName);
+    FormField getField(String fieldName);
 
     default String readFirstValue(String fieldName) {
-        FormField formField = read(fieldName);
+        FormField formField = getField(fieldName);
         if (formField == null) {
             return null;
         }
@@ -41,7 +41,7 @@ public interface FormReader {
     }
 
     default List<? extends CharSequence> readValues(String fieldName) {
-        FormField formField = read(fieldName);
+        FormField formField = getField(fieldName);
         if (formField == null) {
             return Collections.emptyList();
         }
@@ -49,7 +49,7 @@ public interface FormReader {
     }
 
     default List<String> readStringValues(String fieldName) {
-        FormField formField = read(fieldName);
+        FormField formField = getField(fieldName);
         if (formField == null) {
             return Collections.emptyList();
         }
@@ -58,7 +58,7 @@ public interface FormReader {
     }
 
     default Boolean readBoolean(String fieldName) {
-        FormField formField = read(fieldName);
+        FormField formField = getField(fieldName);
         if (formField == null) {
             return null;
         }
@@ -67,7 +67,7 @@ public interface FormReader {
     }
 
     default Integer readInteger(String fieldName) {
-        FormField formField = read(fieldName);
+        FormField formField = getField(fieldName);
         if (formField == null) {
             return null;
         }
@@ -76,7 +76,7 @@ public interface FormReader {
     }
 
     default Date readDate(String fieldName) throws ParseException {
-        FormField formField = read(fieldName);
+        FormField formField = getField(fieldName);
         if (formField == null) {
             return null;
         }

smack-extensions/src/test/java/org/jivesoftware/smackx/pubsub/ConfigureFormTest.java

@@ -79,23 +79,25 @@ public class ConfigureFormTest extends SmackTestSuite {
     }
 
     @Test
-    public void getConfigFormWithTimeout() throws XMPPException, InterruptedException {
+    public void getConfigFormWithTimeout() throws XMPPException, InterruptedException, SmackException, IOException {
-        ThreadedDummyConnection con = new ThreadedDummyConnection();
+        ThreadedDummyConnection con = ThreadedDummyConnection.newInstance();
         PubSubManager mgr = new PubSubManager(con, PubSubManagerTest.DUMMY_PUBSUB_SERVICE);
-        DiscoverInfoBuilder info = DiscoverInfo.builder("disco-result");
+        DiscoverInfoBuilder info = DiscoverInfo.builder("disco-result")
+                                               .ofType(IQ.Type.result)
+                                               .from(PubSubManagerTest.DUMMY_PUBSUB_SERVICE);
+
         Identity ident = new Identity("pubsub", null, "leaf");
         info.addIdentity(ident);
 
         DiscoverInfo discoverInfo = info.build();
         con.addIQReply(discoverInfo);
 
+        Node node = mgr.getNode("princely_musings");
+
+        SmackConfiguration.setDefaultReplyTimeout(100);
+        con.setTimeout();
+
         assertThrows(SmackException.class, () -> {
-            // TODO: This method should not throw any exception but currently does.
-            Node node = mgr.getNode("princely_musings");
-
-            SmackConfiguration.setDefaultReplyTimeout(100);
-            con.setTimeout();
-
             node.getNodeConfiguration();
         });
     }

smack-openpgp/build.gradle

@@ -10,7 +10,7 @@ dependencies {
 
 	api 'org.pgpainless:pgpainless-core:0.0.1-alpha11'
 
-	testImplementation "org.bouncycastle:bcprov-jdk15on:1.65"
+	testImplementation "org.bouncycastle:bcprov-jdk15on:${bouncyCastleVersion}"
 
 	testFixturesApi(testFixtures(project(":smack-core")))
 	testCompile group: 'commons-io', name: 'commons-io', version: "$commonsIoVersion"