mirror of
https://codeberg.org/Mercury-IM/Smack
synced 2025-12-06 21:21:08 +01:00
Introduce Smack's Modular Connection Architecture
This is a complete redesign of what was previously XmppNioTcpConnection. The new architecture allows to extend an XMPP client to server (c2s) connection with new transport bindings and other extensions.
This commit is contained in:
Florian Schmaus
parent
cec312fe64
commit
cc636fff21
142 changed files with 6819 additions and 4068 deletions
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2015-2019 Florian Schmaus
|
||||
* Copyright 2015-2020 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -45,7 +45,7 @@ public abstract class AbstractSmackIntTest {
|
|||
|
||||
protected final Configuration sinttestConfiguration;
|
||||
|
||||
protected AbstractSmackIntTest(SmackIntegrationTestEnvironment<?> environment) {
|
||||
protected AbstractSmackIntTest(SmackIntegrationTestEnvironment environment) {
|
||||
this.testRunId = environment.testRunId;
|
||||
this.sinttestConfiguration = environment.configuration;
|
||||
this.timeout = environment.configuration.replyTimeout;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2015-2018 Florian Schmaus
|
||||
* Copyright 2015-2020 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -46,7 +46,7 @@ public abstract class AbstractSmackIntegrationTest extends AbstractSmackIntTest
|
|||
|
||||
protected final List<XMPPConnection> connections;
|
||||
|
||||
public AbstractSmackIntegrationTest(SmackIntegrationTestEnvironment<?> environment) {
|
||||
public AbstractSmackIntegrationTest(SmackIntegrationTestEnvironment environment) {
|
||||
super(environment);
|
||||
this.connection = this.conOne = environment.conOne;
|
||||
this.conTwo = environment.conTwo;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2015-2019 Florian Schmaus
|
||||
* Copyright 2015-2020 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -31,7 +31,7 @@ import org.jxmpp.jid.DomainBareJid;
|
|||
|
||||
public abstract class AbstractSmackLowLevelIntegrationTest extends AbstractSmackIntTest {
|
||||
|
||||
private final SmackIntegrationTestEnvironment<?> environment;
|
||||
private final SmackIntegrationTestEnvironment environment;
|
||||
|
||||
/**
|
||||
* The configuration
|
||||
|
|
@ -40,7 +40,7 @@ public abstract class AbstractSmackLowLevelIntegrationTest extends AbstractSmack
|
|||
|
||||
protected final DomainBareJid service;
|
||||
|
||||
protected AbstractSmackLowLevelIntegrationTest(SmackIntegrationTestEnvironment<?> environment) {
|
||||
protected AbstractSmackLowLevelIntegrationTest(SmackIntegrationTestEnvironment environment) {
|
||||
super(environment);
|
||||
this.environment = environment;
|
||||
this.configuration = environment.configuration;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2018-2019 Florian Schmaus
|
||||
* Copyright 2018-2020 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -28,19 +28,22 @@ import org.jivesoftware.smack.XMPPException.XMPPErrorException;
|
|||
public abstract class AbstractSmackSpecificLowLevelIntegrationTest<C extends AbstractXMPPConnection>
|
||||
extends AbstractSmackLowLevelIntegrationTest {
|
||||
|
||||
private final SmackIntegrationTestEnvironment<?> environment;
|
||||
private final SmackIntegrationTestEnvironment environment;
|
||||
|
||||
protected final Class<C> connectionClass;
|
||||
|
||||
private final XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor;
|
||||
|
||||
public AbstractSmackSpecificLowLevelIntegrationTest(SmackIntegrationTestEnvironment<?> environment,
|
||||
public AbstractSmackSpecificLowLevelIntegrationTest(SmackIntegrationTestEnvironment environment,
|
||||
Class<C> connectionClass) {
|
||||
super(environment);
|
||||
this.environment = environment;
|
||||
this.connectionClass = connectionClass;
|
||||
|
||||
connectionDescriptor = environment.connectionManager.getConnectionDescriptorFor(connectionClass);
|
||||
if (connectionDescriptor == null) {
|
||||
throw new IllegalStateException("No connection descriptor for " + connectionClass + " known");
|
||||
}
|
||||
}
|
||||
|
||||
public Class<C> getConnectionClass() {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2015-2018 Florian Schmaus
|
||||
* Copyright 2015-2020 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -33,7 +33,9 @@ import javax.net.ssl.SSLContext;
|
|||
|
||||
import org.jivesoftware.smack.ConnectionConfiguration.SecurityMode;
|
||||
import org.jivesoftware.smack.debugger.ConsoleDebugger;
|
||||
import org.jivesoftware.smack.util.Function;
|
||||
import org.jivesoftware.smack.util.Objects;
|
||||
import org.jivesoftware.smack.util.ParserUtils;
|
||||
import org.jivesoftware.smack.util.StringUtils;
|
||||
|
||||
import org.jivesoftware.smackx.debugger.EnhancedDebugger;
|
||||
|
|
@ -94,80 +96,90 @@ public final class Configuration {
|
|||
|
||||
public final Set<String> disabledTests;
|
||||
|
||||
public final String defaultConnectionNickname;
|
||||
|
||||
public final Set<String> enabledConnections;
|
||||
|
||||
public final Set<String> disabledConnections;
|
||||
|
||||
public final Set<String> testPackages;
|
||||
|
||||
public final ConnectionConfigurationBuilderApplier configurationApplier;
|
||||
|
||||
private Configuration(DomainBareJid service, String serviceTlsPin, SecurityMode securityMode, int replyTimeout,
|
||||
Debugger debugger, String accountOneUsername, String accountOnePassword, String accountTwoUsername,
|
||||
String accountTwoPassword, String accountThreeUsername, String accountThreePassword, Set<String> enabledTests, Set<String> disabledTests,
|
||||
Set<String> testPackages, String adminAccountUsername, String adminAccountPassword)
|
||||
throws KeyManagementException, NoSuchAlgorithmException {
|
||||
this.service = Objects.requireNonNull(service,
|
||||
public final boolean verbose;
|
||||
|
||||
private Configuration(Configuration.Builder builder) throws KeyManagementException, NoSuchAlgorithmException {
|
||||
service = Objects.requireNonNull(builder.service,
|
||||
"'service' must be set. Either via 'properties' files or via system property 'sinttest.service'.");
|
||||
this.serviceTlsPin = serviceTlsPin;
|
||||
serviceTlsPin = builder.serviceTlsPin;
|
||||
if (serviceTlsPin != null) {
|
||||
tlsContext = Java7Pinning.forPin(serviceTlsPin);
|
||||
} else {
|
||||
tlsContext = null;
|
||||
}
|
||||
this.securityMode = securityMode;
|
||||
if (replyTimeout > 0) {
|
||||
this.replyTimeout = replyTimeout;
|
||||
securityMode = builder.securityMode;
|
||||
if (builder.replyTimeout > 0) {
|
||||
replyTimeout = builder.replyTimeout;
|
||||
} else {
|
||||
this.replyTimeout = 60000;
|
||||
replyTimeout = 60000;
|
||||
}
|
||||
this.debugger = debugger;
|
||||
if (StringUtils.isNotEmpty(adminAccountUsername, adminAccountPassword)) {
|
||||
debugger = builder.debugger;
|
||||
if (StringUtils.isNotEmpty(builder.adminAccountUsername, builder.adminAccountPassword)) {
|
||||
accountRegistration = AccountRegistration.serviceAdministration;
|
||||
}
|
||||
else if (StringUtils.isNotEmpty(accountOneUsername, accountOnePassword, accountTwoUsername, accountTwoPassword,
|
||||
accountThreeUsername, accountThreePassword)) {
|
||||
else if (StringUtils.isNotEmpty(builder.accountOneUsername, builder.accountOnePassword,
|
||||
builder.accountTwoUsername, builder.accountTwoPassword, builder.accountThreeUsername,
|
||||
builder.accountThreePassword)) {
|
||||
accountRegistration = AccountRegistration.disabled;
|
||||
}
|
||||
else {
|
||||
accountRegistration = AccountRegistration.inBandRegistration;
|
||||
}
|
||||
|
||||
this.adminAccountUsername = adminAccountUsername;
|
||||
this.adminAccountPassword = adminAccountPassword;
|
||||
this.adminAccountUsername = builder.adminAccountUsername;
|
||||
this.adminAccountPassword = builder.adminAccountPassword;
|
||||
|
||||
boolean accountOnePasswordSet = StringUtils.isNotEmpty(accountOnePassword);
|
||||
if (accountOnePasswordSet != StringUtils.isNotEmpty(accountTwoPassword) ||
|
||||
accountOnePasswordSet != StringUtils.isNotEmpty(accountThreePassword)) {
|
||||
boolean accountOnePasswordSet = StringUtils.isNotEmpty(builder.accountOnePassword);
|
||||
if (accountOnePasswordSet != StringUtils.isNotEmpty(builder.accountTwoPassword) ||
|
||||
accountOnePasswordSet != StringUtils.isNotEmpty(builder.accountThreePassword)) {
|
||||
// Ensure the invariant that either all main accounts have a password set, or none.
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
|
||||
this.accountOneUsername = accountOneUsername;
|
||||
this.accountOnePassword = accountOnePassword;
|
||||
this.accountTwoUsername = accountTwoUsername;
|
||||
this.accountTwoPassword = accountTwoPassword;
|
||||
this.accountThreeUsername = accountThreeUsername;
|
||||
this.accountThreePassword = accountThreePassword;
|
||||
this.enabledTests = enabledTests;
|
||||
this.disabledTests = disabledTests;
|
||||
this.testPackages = testPackages;
|
||||
this.accountOneUsername = builder.accountOneUsername;
|
||||
this.accountOnePassword = builder.accountOnePassword;
|
||||
this.accountTwoUsername = builder.accountTwoUsername;
|
||||
this.accountTwoPassword = builder.accountTwoPassword;
|
||||
this.accountThreeUsername = builder.accountThreeUsername;
|
||||
this.accountThreePassword = builder.accountThreePassword;
|
||||
this.enabledTests = builder.enabledTests;
|
||||
this.disabledTests = builder.disabledTests;
|
||||
this.defaultConnectionNickname = builder.defaultConnectionNickname;
|
||||
this.enabledConnections = builder.enabledConnections;
|
||||
this.disabledConnections = builder.disabledConnections;
|
||||
this.testPackages = builder.testPackages;
|
||||
|
||||
this.configurationApplier = builder -> {
|
||||
this.configurationApplier = b -> {
|
||||
if (tlsContext != null) {
|
||||
builder.setCustomSSLContext(tlsContext);
|
||||
b.setCustomSSLContext(tlsContext);
|
||||
}
|
||||
builder.setSecurityMode(securityMode);
|
||||
builder.setXmppDomain(service);
|
||||
b.setSecurityMode(securityMode);
|
||||
b.setXmppDomain(service);
|
||||
|
||||
switch (debugger) {
|
||||
case enhanced:
|
||||
builder.setDebuggerFactory(EnhancedDebugger.Factory.INSTANCE);
|
||||
b.setDebuggerFactory(EnhancedDebugger.Factory.INSTANCE);
|
||||
break;
|
||||
case console:
|
||||
builder.setDebuggerFactory(ConsoleDebugger.Factory.INSTANCE);
|
||||
b.setDebuggerFactory(ConsoleDebugger.Factory.INSTANCE);
|
||||
break;
|
||||
case none:
|
||||
// Nothing to do :).
|
||||
break;
|
||||
}
|
||||
};
|
||||
|
||||
this.verbose = builder.verbose;
|
||||
}
|
||||
|
||||
public boolean isAccountRegistrationPossible() {
|
||||
|
|
@ -210,8 +222,16 @@ public final class Configuration {
|
|||
|
||||
private Set<String> disabledTests;
|
||||
|
||||
private String defaultConnectionNickname;
|
||||
|
||||
private Set<String> enabledConnections;
|
||||
|
||||
private Set<String> disabledConnections;
|
||||
|
||||
private Set<String> testPackages;
|
||||
|
||||
private boolean verbose;
|
||||
|
||||
private Builder() {
|
||||
}
|
||||
|
||||
|
|
@ -324,6 +344,21 @@ public final class Configuration {
|
|||
return this;
|
||||
}
|
||||
|
||||
public Builder setDefaultConnection(String defaultConnectionNickname) {
|
||||
this.defaultConnectionNickname = defaultConnectionNickname;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder setEnabledConnections(String enabledConnectionsString) {
|
||||
enabledConnections = split(enabledConnectionsString);
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder setDisabledConnections(String disabledConnectionsString) {
|
||||
disabledConnections = split(disabledConnectionsString);
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder addTestPackages(String testPackagesString) {
|
||||
if (testPackagesString != null) {
|
||||
String[] testPackagesArray = testPackagesString.split(",");
|
||||
|
|
@ -350,10 +385,22 @@ public final class Configuration {
|
|||
return this;
|
||||
}
|
||||
|
||||
public Builder setVerbose(boolean verbose) {
|
||||
this.verbose = verbose;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder setVerbose(String verboseBooleanString) {
|
||||
if (verboseBooleanString == null) {
|
||||
return this;
|
||||
}
|
||||
|
||||
boolean verbose = ParserUtils.parseXmlBoolean(verboseBooleanString);
|
||||
return setVerbose(verbose);
|
||||
}
|
||||
|
||||
public Configuration build() throws KeyManagementException, NoSuchAlgorithmException {
|
||||
return new Configuration(service, serviceTlsPin, securityMode, replyTimeout, debugger, accountOneUsername,
|
||||
accountOnePassword, accountTwoUsername, accountTwoPassword, accountThreeUsername, accountThreePassword, enabledTests, disabledTests,
|
||||
testPackages, adminAccountUsername, adminAccountPassword);
|
||||
return new Configuration(this);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -414,10 +461,15 @@ public final class Configuration {
|
|||
builder.setDebugger(properties.getProperty("debugger"));
|
||||
builder.setEnabledTests(properties.getProperty("enabledTests"));
|
||||
builder.setDisabledTests(properties.getProperty("disabledTests"));
|
||||
builder.setDefaultConnection(properties.getProperty("defaultConnection"));
|
||||
builder.setEnabledConnections(properties.getProperty("enabledConnections"));
|
||||
builder.setDisabledConnections(properties.getProperty("disabledConnections"));
|
||||
|
||||
builder.addTestPackages(properties.getProperty("testPackages"));
|
||||
builder.addTestPackages(testPackages);
|
||||
|
||||
builder.setVerbose(properties.getProperty("verbose"));
|
||||
|
||||
return builder.build();
|
||||
}
|
||||
|
||||
|
|
@ -437,23 +489,36 @@ public final class Configuration {
|
|||
return null;
|
||||
}
|
||||
|
||||
private static Set<String> getTestSetFrom(String string) {
|
||||
if (string == null) {
|
||||
private static Set<String> split(String input) {
|
||||
return split(input, Function.identity());
|
||||
}
|
||||
|
||||
private static Set<String> split(String input, Function<String, String> transformer) {
|
||||
if (input == null) {
|
||||
return null;
|
||||
}
|
||||
String[] stringArray = string.split(",");
|
||||
Set<String> res = new HashSet<>(stringArray.length);
|
||||
for (String s : stringArray) {
|
||||
res.add(getFullTestStringFrom(s));
|
||||
|
||||
String[] inputArray = input.split(",");
|
||||
Set<String> res = new HashSet<>(inputArray.length);
|
||||
for (String s : inputArray) {
|
||||
s = transformer.apply(s);
|
||||
boolean newElement = res.add(s);
|
||||
if (!newElement) {
|
||||
throw new IllegalArgumentException("The argument '" + s + "' was already provided.");
|
||||
}
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
private static String getFullTestStringFrom(String string) {
|
||||
string = string.trim();
|
||||
if (string.startsWith("smackx.") || string.startsWith("smack.")) {
|
||||
string = "org.jivesoftware." + string;
|
||||
}
|
||||
return string;
|
||||
private static Set<String> getTestSetFrom(String input) {
|
||||
return split(input, s -> {
|
||||
s = s.trim();
|
||||
if (s.startsWith("smackx.") || s.startsWith("smack.")) {
|
||||
s = "org.jivesoftware." + s;
|
||||
}
|
||||
return s;
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2015-2019 Florian Schmaus
|
||||
* Copyright 2015-2020 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -18,18 +18,18 @@ package org.igniterealtime.smack.inttest;
|
|||
|
||||
import org.jivesoftware.smack.AbstractXMPPConnection;
|
||||
|
||||
public class SmackIntegrationTestEnvironment<C extends AbstractXMPPConnection> {
|
||||
public class SmackIntegrationTestEnvironment {
|
||||
|
||||
public final C conOne, conTwo, conThree;
|
||||
public final AbstractXMPPConnection conOne, conTwo, conThree;
|
||||
|
||||
public final String testRunId;
|
||||
|
||||
public final Configuration configuration;
|
||||
|
||||
public final XmppConnectionManager<C> connectionManager;
|
||||
public final XmppConnectionManager connectionManager;
|
||||
|
||||
SmackIntegrationTestEnvironment(C conOne, C conTwo, C conThree, String testRunId,
|
||||
Configuration configuration, XmppConnectionManager<C> connectionManager) {
|
||||
SmackIntegrationTestEnvironment(AbstractXMPPConnection conOne, AbstractXMPPConnection conTwo, AbstractXMPPConnection conThree, String testRunId,
|
||||
Configuration configuration, XmppConnectionManager connectionManager) {
|
||||
this.conOne = conOne;
|
||||
this.conTwo = conTwo;
|
||||
this.conThree = conThree;
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ import static org.reflections.ReflectionUtils.withParametersCount;
|
|||
import static org.reflections.ReflectionUtils.withReturnType;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.lang.reflect.Constructor;
|
||||
import java.lang.reflect.InvocationTargetException;
|
||||
import java.lang.reflect.Method;
|
||||
|
|
@ -43,7 +44,6 @@ import java.util.Locale;
|
|||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
|
|
@ -53,7 +53,6 @@ import org.jivesoftware.smack.SmackConfiguration;
|
|||
import org.jivesoftware.smack.SmackException;
|
||||
import org.jivesoftware.smack.SmackException.NoResponseException;
|
||||
import org.jivesoftware.smack.XMPPException;
|
||||
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
|
||||
import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
|
||||
import org.jivesoftware.smack.util.StringUtils;
|
||||
import org.jivesoftware.smack.util.TLSUtils;
|
||||
|
|
@ -70,7 +69,7 @@ import org.reflections.scanners.MethodParameterScanner;
|
|||
import org.reflections.scanners.SubTypesScanner;
|
||||
import org.reflections.scanners.TypeAnnotationsScanner;
|
||||
|
||||
public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
||||
public class SmackIntegrationTestFramework {
|
||||
|
||||
static {
|
||||
TLSUtils.setDefaultTrustStoreTypeToJksIfRequired();
|
||||
|
|
@ -80,14 +79,12 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
|
||||
public static boolean SINTTEST_UNIT_TEST = false;
|
||||
|
||||
private final Class<DC> defaultConnectionClass;
|
||||
|
||||
protected final Configuration config;
|
||||
|
||||
protected TestRunResult testRunResult;
|
||||
|
||||
private SmackIntegrationTestEnvironment<DC> environment;
|
||||
protected XmppConnectionManager<DC> connectionManager;
|
||||
private SmackIntegrationTestEnvironment environment;
|
||||
protected XmppConnectionManager connectionManager;
|
||||
|
||||
public enum TestType {
|
||||
Normal,
|
||||
|
|
@ -100,7 +97,7 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
IllegalAccessException, IllegalArgumentException, InvocationTargetException {
|
||||
Configuration config = Configuration.newConfiguration(args);
|
||||
|
||||
SmackIntegrationTestFramework<XMPPTCPConnection> sinttest = new SmackIntegrationTestFramework<>(config, XMPPTCPConnection.class);
|
||||
SmackIntegrationTestFramework sinttest = new SmackIntegrationTestFramework(config);
|
||||
TestRunResult testRunResult = sinttest.run();
|
||||
|
||||
for (Entry<Class<? extends AbstractSmackIntTest>, Throwable> entry : testRunResult.impossibleTestClasses.entrySet()) {
|
||||
|
|
@ -116,11 +113,9 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
}
|
||||
final int successfulTests = testRunResult.successfulIntegrationTests.size();
|
||||
final int failedTests = testRunResult.failedIntegrationTests.size();
|
||||
final int totalIntegrationTests = successfulTests + failedTests;
|
||||
final int availableTests = testRunResult.getNumberOfAvailableTests();
|
||||
final int possibleTests = testRunResult.getNumberOfPossibleTests();
|
||||
LOGGER.info("SmackIntegrationTestFramework[" + testRunResult.testRunId + ']' + ": Finished ["
|
||||
+ successfulTests + '/' + totalIntegrationTests + "] (" + possibleTests + " test methods of " + availableTests + " where possible)");
|
||||
LOGGER.info("SmackIntegrationTestFramework[" + testRunResult.testRunId + ']' + " finished: "
|
||||
+ successfulTests + '/' + availableTests + " [" + failedTests + " failed]");
|
||||
|
||||
final int exitStatus;
|
||||
if (failedTests > 0) {
|
||||
|
|
@ -146,12 +141,8 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
System.exit(exitStatus);
|
||||
}
|
||||
|
||||
public SmackIntegrationTestFramework(Configuration configuration, Class<DC> defaultConnectionClass)
|
||||
throws KeyManagementException, InstantiationException, IllegalAccessException, IllegalArgumentException,
|
||||
InvocationTargetException, NoSuchAlgorithmException, SmackException, IOException, XMPPException,
|
||||
InterruptedException {
|
||||
public SmackIntegrationTestFramework(Configuration configuration) {
|
||||
this.config = configuration;
|
||||
this.defaultConnectionClass = defaultConnectionClass;
|
||||
}
|
||||
|
||||
public synchronized TestRunResult run()
|
||||
|
|
@ -160,7 +151,7 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
testRunResult = new TestRunResult();
|
||||
|
||||
// Create a connection manager *after* we created the testRunId (in testRunResult).
|
||||
this.connectionManager = new XmppConnectionManager<>(this, defaultConnectionClass);
|
||||
this.connectionManager = new XmppConnectionManager(this);
|
||||
|
||||
LOGGER.info("SmackIntegrationTestFramework [" + testRunResult.testRunId + ']' + ": Starting");
|
||||
if (config.debugger != Configuration.Debugger.none) {
|
||||
|
|
@ -226,10 +217,13 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
return testRunResult;
|
||||
}
|
||||
|
||||
@SuppressWarnings({"unchecked", "Finally"})
|
||||
@SuppressWarnings({"Finally"})
|
||||
private void runTests(Set<Class<? extends AbstractSmackIntTest>> classes)
|
||||
throws InterruptedException, InstantiationException, IllegalAccessException,
|
||||
IllegalArgumentException, SmackException, IOException, XMPPException {
|
||||
List<PreparedTest> tests = new ArrayList<>(classes.size());
|
||||
int numberOfAvailableTests = 0;
|
||||
|
||||
for (Class<? extends AbstractSmackIntTest> testClass : classes) {
|
||||
final String testClassName = testClass.getName();
|
||||
|
||||
|
|
@ -260,17 +254,19 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
// - https://discuss.gradle.org/t/main-vs-test-compile-vs-runtime-classpaths-in-eclipse-once-and-for-all-how/17403
|
||||
// - https://bugs.eclipse.org/bugs/show_bug.cgi?id=376616 (Scope of dependencies has no effect on Eclipse compilation)
|
||||
if (!SINTTEST_UNIT_TEST && testClassName.startsWith("org.igniterealtime.smack.inttest.unittest")) {
|
||||
LOGGER.finer("Skipping integration test '" + testClassName + "' from src/test classpath");
|
||||
LOGGER.warning("Skipping integration test '" + testClassName + "' from src/test classpath (should not be in classpath)");
|
||||
continue;
|
||||
}
|
||||
|
||||
if (config.enabledTests != null && !isInSet(testClass, config.enabledTests)) {
|
||||
LOGGER.info("Skipping test class " + testClassName + " because it is not enabled");
|
||||
DisabledTestClass disabledTestClass = new DisabledTestClass(testClass, "Skipping test class " + testClassName + " because it is not enabled");
|
||||
testRunResult.disabledTestClasses.add(disabledTestClass);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (isInSet(testClass, config.disabledTests)) {
|
||||
LOGGER.info("Skipping test class " + testClassName + " because it is disalbed");
|
||||
DisabledTestClass disabledTestClass = new DisabledTestClass(testClass, "Skipping test class " + testClassName + " because it is disalbed");
|
||||
testRunResult.disabledTestClasses.add(disabledTestClass);
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -301,8 +297,6 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
continue;
|
||||
}
|
||||
|
||||
testRunResult.numberOfAvailableTestMethods.addAndGet(smackIntegrationTestMethods.size());
|
||||
|
||||
final AbstractSmackIntTest test;
|
||||
try {
|
||||
test = cons.newInstance(environment);
|
||||
|
|
@ -360,12 +354,14 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
final String methodName = method.getName();
|
||||
if (config.enabledTests != null && !(config.enabledTests.contains(methodName)
|
||||
|| isInSet(testClass, config.enabledTests))) {
|
||||
LOGGER.fine("Skipping test method " + methodName + " because it is not enabled");
|
||||
DisabledTest disabledTest = new DisabledTest(method, "Skipping test method " + methodName + " because it is not enabled");
|
||||
testRunResult.disabledTests.add(disabledTest);
|
||||
it.remove();
|
||||
continue;
|
||||
}
|
||||
if (config.disabledTests != null && config.disabledTests.contains(methodName)) {
|
||||
LOGGER.info("Skipping test method " + methodName + " because it is disabled");
|
||||
DisabledTest disabledTest = new DisabledTest(method, "Skipping test method " + methodName + " because it is disabled");
|
||||
testRunResult.disabledTests.add(disabledTest);
|
||||
it.remove();
|
||||
continue;
|
||||
}
|
||||
|
|
@ -376,106 +372,77 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
continue;
|
||||
}
|
||||
|
||||
final int detectedTestMethodsCount = smackIntegrationTestMethods.size();
|
||||
testRunResult.numberOfPossibleTestMethods.addAndGet(detectedTestMethodsCount);
|
||||
List<ConcreteTest> concreteTests = new ArrayList<>(smackIntegrationTestMethods.size());
|
||||
|
||||
try {
|
||||
// Run the @BeforeClass methods (if any)
|
||||
Set<Method> beforeClassMethods = getAllMethods(testClass,
|
||||
withAnnotation(BeforeClass.class), withReturnType(Void.TYPE),
|
||||
withParametersCount(0), withModifier(Modifier.PUBLIC
|
||||
));
|
||||
|
||||
// See if there are any methods that have the @BeforeClassAnnotation but a wrong signature
|
||||
Set<Method> allBeforeClassMethods = getAllMethods(testClass, withAnnotation(BeforeClass.class));
|
||||
allBeforeClassMethods.removeAll(beforeClassMethods);
|
||||
if (!allBeforeClassMethods.isEmpty()) {
|
||||
throw new IllegalArgumentException("@BeforeClass methods with wrong signature found");
|
||||
for (Method testMethod : smackIntegrationTestMethods) {
|
||||
switch (testType) {
|
||||
case Normal: {
|
||||
ConcreteTest.Executor concreteTestExecutor = () -> testMethod.invoke(test);
|
||||
ConcreteTest concreteTest = new ConcreteTest(testType, testMethod, concreteTestExecutor);
|
||||
concreteTests.add(concreteTest);
|
||||
}
|
||||
|
||||
if (beforeClassMethods.size() == 1) {
|
||||
Method beforeClassMethod = beforeClassMethods.iterator().next();
|
||||
LOGGER.info("Executing @BeforeClass method of " + testClass);
|
||||
try {
|
||||
beforeClassMethod.invoke(test);
|
||||
}
|
||||
catch (InvocationTargetException | IllegalAccessException e) {
|
||||
LOGGER.log(Level.SEVERE, "Exception executing @BeforeClass method", e);
|
||||
}
|
||||
catch (IllegalArgumentException e) {
|
||||
throw new AssertionError(e);
|
||||
}
|
||||
}
|
||||
else if (beforeClassMethods.size() > 1) {
|
||||
throw new IllegalArgumentException("Only one @BeforeClass method allowed");
|
||||
}
|
||||
|
||||
for (Method testMethod : smackIntegrationTestMethods) {
|
||||
List<ConcreteTest> concreteTests = null;
|
||||
break;
|
||||
case LowLevel:
|
||||
case SpecificLowLevel:
|
||||
LowLevelTestMethod lowLevelTestMethod = new LowLevelTestMethod(testMethod);
|
||||
switch (testType) {
|
||||
case Normal: {
|
||||
ConcreteTest.Executor concreteTestExecutor = () -> testMethod.invoke(test);
|
||||
ConcreteTest concreteTest = new ConcreteTest(testType, testMethod, concreteTestExecutor);
|
||||
concreteTests = Collections.singletonList(concreteTest);
|
||||
}
|
||||
break;
|
||||
case LowLevel:
|
||||
case SpecificLowLevel:
|
||||
LowLevelTestMethod lowLevelTestMethod = new LowLevelTestMethod(testMethod);
|
||||
switch (testType) {
|
||||
case LowLevel:
|
||||
concreteTests = invokeLowLevel(lowLevelTestMethod, (AbstractSmackLowLevelIntegrationTest) test);
|
||||
break;
|
||||
case SpecificLowLevel: {
|
||||
ConcreteTest.Executor concreteTestExecutor = () -> invokeSpecificLowLevel(
|
||||
lowLevelTestMethod, (AbstractSmackSpecificLowLevelIntegrationTest<?>) test);
|
||||
ConcreteTest concreteTest = new ConcreteTest(testType, testMethod, concreteTestExecutor);
|
||||
concreteTests = Collections.singletonList(concreteTest);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
throw new AssertionError();
|
||||
}
|
||||
List<ConcreteTest> concreteLowLevelTests = invokeLowLevel(lowLevelTestMethod, (AbstractSmackLowLevelIntegrationTest) test);
|
||||
concreteTests.addAll(concreteLowLevelTests);
|
||||
break;
|
||||
case SpecificLowLevel: {
|
||||
ConcreteTest.Executor concreteTestExecutor = () -> invokeSpecificLowLevel(
|
||||
lowLevelTestMethod, (AbstractSmackSpecificLowLevelIntegrationTest<?>) test);
|
||||
ConcreteTest concreteTest = new ConcreteTest(testType, testMethod, concreteTestExecutor);
|
||||
concreteTests.add(concreteTest);
|
||||
break;
|
||||
}
|
||||
|
||||
for (ConcreteTest concreteTest : concreteTests) {
|
||||
runConcreteTest(concreteTest);
|
||||
default:
|
||||
throw new AssertionError();
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
finally {
|
||||
// Run the @AfterClass method (if any)
|
||||
Set<Method> afterClassMethods = getAllMethods(testClass,
|
||||
withAnnotation(AfterClass.class), withReturnType(Void.TYPE),
|
||||
withParametersCount(0), withModifier(Modifier.PUBLIC
|
||||
));
|
||||
|
||||
// See if there are any methods that have the @AfterClassAnnotation but a wrong signature
|
||||
Set<Method> allAfterClassMethods = getAllMethods(testClass, withAnnotation(AfterClass.class));
|
||||
allAfterClassMethods.removeAll(afterClassMethods);
|
||||
if (!allAfterClassMethods.isEmpty()) {
|
||||
throw new IllegalArgumentException("@AfterClass methods with wrong signature found");
|
||||
}
|
||||
// Instantiate the prepared test early as this will check the before and after class annotations.
|
||||
PreparedTest preparedTest = new PreparedTest(test, concreteTests);
|
||||
tests.add(preparedTest);
|
||||
|
||||
if (afterClassMethods.size() == 1) {
|
||||
Method afterClassMethod = afterClassMethods.iterator().next();
|
||||
LOGGER.info("Executing @AfterClass method of " + testClass);
|
||||
try {
|
||||
afterClassMethod.invoke(test);
|
||||
}
|
||||
catch (InvocationTargetException | IllegalAccessException e) {
|
||||
LOGGER.log(Level.SEVERE, "Exception executing @AfterClass method", e);
|
||||
}
|
||||
catch (IllegalArgumentException e) {
|
||||
throw new AssertionError(e);
|
||||
}
|
||||
}
|
||||
else if (afterClassMethods.size() > 1) {
|
||||
throw new IllegalArgumentException("Only one @AfterClass method allowed");
|
||||
}
|
||||
}
|
||||
numberOfAvailableTests += concreteTests.size();
|
||||
}
|
||||
|
||||
// Print status information.
|
||||
StringBuilder sb = new StringBuilder(1024);
|
||||
sb.append("Smack Integration Test Framework\n");
|
||||
sb.append("################################\n");
|
||||
if (config.verbose) {
|
||||
sb.append('\n');
|
||||
if (!testRunResult.disabledTestClasses.isEmpty()) {
|
||||
sb.append("The following test classes are disabled:\n");
|
||||
for (DisabledTestClass disabledTestClass : testRunResult.disabledTestClasses) {
|
||||
disabledTestClass.appendTo(sb).append('\n');
|
||||
}
|
||||
}
|
||||
if (!testRunResult.disabledTests.isEmpty()) {
|
||||
sb.append("The following tests are disabled:\n");
|
||||
for (DisabledTest disabledTest : testRunResult.disabledTests) {
|
||||
disabledTest.appendTo(sb).append('\n');
|
||||
}
|
||||
}
|
||||
sb.append('\n');
|
||||
}
|
||||
sb.append("Available tests: ").append(numberOfAvailableTests)
|
||||
.append("(#-classes: ").append(testRunResult.disabledTestClasses.size())
|
||||
.append(", #-tests: ").append(testRunResult.disabledTests.size())
|
||||
.append(")\n");
|
||||
LOGGER.info(sb.toString());
|
||||
|
||||
for (PreparedTest test : tests) {
|
||||
test.run();
|
||||
}
|
||||
|
||||
// Assert that all tests in the 'tests' list produced a result.
|
||||
assert numberOfAvailableTests == testRunResult.getNumberOfAvailableTests();
|
||||
}
|
||||
|
||||
private void runConcreteTest(ConcreteTest concreteTest)
|
||||
|
|
@ -524,17 +491,35 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
}
|
||||
|
||||
private List<ConcreteTest> invokeLowLevel(LowLevelTestMethod lowLevelTestMethod, AbstractSmackLowLevelIntegrationTest test) {
|
||||
Set<Class<? extends AbstractXMPPConnection>> connectionClasses;
|
||||
Collection<? extends XmppConnectionDescriptor<?, ?, ?>> connectionDescriptors;
|
||||
if (lowLevelTestMethod.smackIntegrationTestAnnotation.onlyDefaultConnectionType()) {
|
||||
Class<? extends AbstractXMPPConnection> defaultConnectionClass = connectionManager.getDefaultConnectionClass();
|
||||
connectionClasses = Collections.singleton(defaultConnectionClass);
|
||||
XmppConnectionDescriptor<?, ?, ?> defaultConnectionDescriptor = connectionManager.getDefaultConnectionDescriptor();
|
||||
connectionDescriptors = Collections.singleton(defaultConnectionDescriptor);
|
||||
} else {
|
||||
connectionClasses = connectionManager.getConnectionClasses();
|
||||
connectionDescriptors = connectionManager.getConnectionDescriptors();
|
||||
}
|
||||
|
||||
List<ConcreteTest> resultingConcreteTests = new ArrayList<>(connectionClasses.size());
|
||||
List<ConcreteTest> resultingConcreteTests = new ArrayList<>(connectionDescriptors.size());
|
||||
|
||||
for (XmppConnectionDescriptor<?, ?, ?> connectionDescriptor : connectionDescriptors) {
|
||||
String connectionNick = connectionDescriptor.getNickname();
|
||||
|
||||
if (config.enabledConnections != null && !config.enabledConnections.contains(connectionNick)) {
|
||||
DisabledTest disabledTest = new DisabledTest(lowLevelTestMethod.testMethod, "Not creating test for " + lowLevelTestMethod + " with connection '" + connectionNick
|
||||
+ "', as this connection type is not enabled");
|
||||
testRunResult.disabledTests.add(disabledTest);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (config.disabledConnections != null && config.disabledConnections.contains(connectionNick)) {
|
||||
DisabledTest disabledTest = new DisabledTest(lowLevelTestMethod.testMethod, "Not creating test for " + lowLevelTestMethod + " with connection '" + connectionNick
|
||||
+ ", as this connection type is disabled");
|
||||
testRunResult.disabledTests.add(disabledTest);
|
||||
continue;
|
||||
}
|
||||
|
||||
Class<? extends AbstractXMPPConnection> connectionClass = connectionDescriptor.getConnectionClass();
|
||||
|
||||
for (Class<? extends AbstractXMPPConnection> connectionClass : connectionClasses) {
|
||||
ConcreteTest.Executor executor = () -> lowLevelTestMethod.invoke(test, connectionClass);
|
||||
ConcreteTest concreteTest = new ConcreteTest(TestType.LowLevel, lowLevelTestMethod.testMethod, executor, connectionClass.getSimpleName());
|
||||
resultingConcreteTests.add(concreteTest);
|
||||
|
|
@ -543,7 +528,7 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
return resultingConcreteTests;
|
||||
}
|
||||
|
||||
private <C extends AbstractXMPPConnection> void invokeSpecificLowLevel(LowLevelTestMethod testMethod,
|
||||
private static <C extends AbstractXMPPConnection> void invokeSpecificLowLevel(LowLevelTestMethod testMethod,
|
||||
AbstractSmackSpecificLowLevelIntegrationTest<C> test)
|
||||
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InterruptedException,
|
||||
SmackException, IOException, XMPPException {
|
||||
|
|
@ -554,7 +539,7 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
testMethod.invoke(test, connectionClass);
|
||||
}
|
||||
|
||||
protected SmackIntegrationTestEnvironment<DC> prepareEnvironment() throws SmackException,
|
||||
protected SmackIntegrationTestEnvironment prepareEnvironment() throws SmackException,
|
||||
IOException, XMPPException, InterruptedException, KeyManagementException,
|
||||
NoSuchAlgorithmException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
|
||||
return connectionManager.prepareEnvironment();
|
||||
|
|
@ -576,9 +561,6 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
|
||||
private static Exception throwFatalException(Throwable e) throws Error, NoResponseException,
|
||||
InterruptedException {
|
||||
if (e instanceof NoResponseException) {
|
||||
throw (NoResponseException) e;
|
||||
}
|
||||
if (e instanceof InterruptedException) {
|
||||
throw (InterruptedException) e;
|
||||
}
|
||||
|
|
@ -612,9 +594,13 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
private final List<SuccessfulTest> successfulIntegrationTests = Collections.synchronizedList(new LinkedList<SuccessfulTest>());
|
||||
private final List<FailedTest> failedIntegrationTests = Collections.synchronizedList(new LinkedList<FailedTest>());
|
||||
private final List<TestNotPossible> impossibleIntegrationTests = Collections.synchronizedList(new LinkedList<TestNotPossible>());
|
||||
|
||||
// TODO: Ideally three would only be a list of disabledTests, but since we do not process a disabled test class
|
||||
// any further, we can not determine the concrete disabled tests.
|
||||
private final List<DisabledTestClass> disabledTestClasses = Collections.synchronizedList(new ArrayList<>());
|
||||
private final List<DisabledTest> disabledTests = Collections.synchronizedList(new ArrayList<>());
|
||||
|
||||
private final Map<Class<? extends AbstractSmackIntTest>, Throwable> impossibleTestClasses = new HashMap<>();
|
||||
private final AtomicInteger numberOfAvailableTestMethods = new AtomicInteger();
|
||||
private final AtomicInteger numberOfPossibleTestMethods = new AtomicInteger();
|
||||
|
||||
TestRunResult() {
|
||||
}
|
||||
|
|
@ -624,11 +610,7 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
}
|
||||
|
||||
public int getNumberOfAvailableTests() {
|
||||
return numberOfAvailableTestMethods.get();
|
||||
}
|
||||
|
||||
public int getNumberOfPossibleTests() {
|
||||
return numberOfPossibleTestMethods.get();
|
||||
return successfulIntegrationTests.size() + failedIntegrationTests.size() + impossibleIntegrationTests.size();
|
||||
}
|
||||
|
||||
public List<SuccessfulTest> getSuccessfulTests() {
|
||||
|
|
@ -648,6 +630,77 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
}
|
||||
}
|
||||
|
||||
final class PreparedTest {
|
||||
private final AbstractSmackIntTest test;
|
||||
private final List<ConcreteTest> concreteTests;
|
||||
|
||||
private final Method beforeClassMethod;
|
||||
private final Method afterClassMethod;
|
||||
|
||||
private PreparedTest(AbstractSmackIntTest test, List<ConcreteTest> concreteTests) {
|
||||
this.test = test;
|
||||
this.concreteTests = concreteTests;
|
||||
Class<? extends AbstractSmackIntTest> testClass = test.getClass();
|
||||
|
||||
beforeClassMethod = getSinttestSpecialMethod(testClass, BeforeClass.class);
|
||||
afterClassMethod = getSinttestSpecialMethod(testClass, AfterClass.class);
|
||||
}
|
||||
|
||||
public void run() throws InterruptedException, XMPPException, IOException, SmackException {
|
||||
try {
|
||||
// Run the @BeforeClass methods (if any)
|
||||
executeSinttestSpecialMethod(beforeClassMethod);
|
||||
|
||||
for (ConcreteTest concreteTest : concreteTests) {
|
||||
runConcreteTest(concreteTest);
|
||||
}
|
||||
}
|
||||
finally {
|
||||
executeSinttestSpecialMethod(afterClassMethod);
|
||||
}
|
||||
}
|
||||
|
||||
private void executeSinttestSpecialMethod(Method method) {
|
||||
if (method == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
method.invoke(test);
|
||||
}
|
||||
catch (InvocationTargetException | IllegalAccessException e) {
|
||||
LOGGER.log(Level.SEVERE, "Exception executing " + method, e);
|
||||
}
|
||||
catch (IllegalArgumentException e) {
|
||||
throw new AssertionError(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static Method getSinttestSpecialMethod(Class<? extends AbstractSmackIntTest> testClass, Class<? extends Annotation> annotation) {
|
||||
Set<Method> specialClassMethods = getAllMethods(testClass,
|
||||
withAnnotation(annotation), withReturnType(Void.TYPE),
|
||||
withParametersCount(0), withModifier(Modifier.PUBLIC
|
||||
));
|
||||
|
||||
// See if there are any methods that have a special but a wrong signature
|
||||
Set<Method> allSpecialClassMethods = getAllMethods(testClass, withAnnotation(annotation));
|
||||
allSpecialClassMethods.removeAll(specialClassMethods);
|
||||
if (!allSpecialClassMethods.isEmpty()) {
|
||||
throw new IllegalArgumentException(annotation + " methods with wrong signature found");
|
||||
}
|
||||
|
||||
if (specialClassMethods.size() == 1) {
|
||||
return specialClassMethods.iterator().next();
|
||||
}
|
||||
else if (specialClassMethods.size() > 1) {
|
||||
throw new IllegalArgumentException("Only one @BeforeClass method allowed");
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
static final class ConcreteTest {
|
||||
private final TestType testType;
|
||||
private final Method method;
|
||||
|
|
@ -705,6 +758,50 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
}
|
||||
}
|
||||
|
||||
public static final class DisabledTestClass {
|
||||
private final Class<? extends AbstractSmackIntTest> testClass;
|
||||
private final String reason;
|
||||
|
||||
private DisabledTestClass(Class<? extends AbstractSmackIntTest> testClass, String reason) {
|
||||
this.testClass = testClass;
|
||||
this.reason = reason;
|
||||
}
|
||||
|
||||
public Class<? extends AbstractSmackIntTest> getTestClass() {
|
||||
return testClass;
|
||||
}
|
||||
|
||||
public String getReason() {
|
||||
return reason;
|
||||
}
|
||||
|
||||
public StringBuilder appendTo(StringBuilder sb) {
|
||||
return sb.append("Disabled ").append(testClass).append(" because ").append(reason);
|
||||
}
|
||||
}
|
||||
|
||||
public static final class DisabledTest {
|
||||
private final Method method;
|
||||
private final String reason;
|
||||
|
||||
private DisabledTest(Method method, String reason) {
|
||||
this.method = method;
|
||||
this.reason = reason;
|
||||
}
|
||||
|
||||
public Method getMethod() {
|
||||
return method;
|
||||
}
|
||||
|
||||
public String getReason() {
|
||||
return reason;
|
||||
}
|
||||
|
||||
public StringBuilder appendTo(StringBuilder sb) {
|
||||
return sb.append("Disabled ").append(method).append(" because ").append(reason);
|
||||
}
|
||||
}
|
||||
|
||||
private final class LowLevelTestMethod {
|
||||
private final Method testMethod;
|
||||
private final SmackIntegrationTest smackIntegrationTestAnnotation;
|
||||
|
|
@ -718,6 +815,7 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
parameterListOfConnections = testMethodParametersIsListOfConnections(testMethod);
|
||||
}
|
||||
|
||||
// TODO: The second parameter should probably be a connection descriptor?
|
||||
private void invoke(AbstractSmackLowLevelIntegrationTest test,
|
||||
Class<? extends AbstractXMPPConnection> connectionClass)
|
||||
throws IllegalAccessException, IllegalArgumentException, InvocationTargetException,
|
||||
|
|
@ -746,6 +844,11 @@ public class SmackIntegrationTestFramework<DC extends AbstractXMPPConnection> {
|
|||
testMethod.invoke(test, connectionsArray);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return testMethod.toString();
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean testMethodParametersIsListOfConnections(Method testMethod) {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2018-2019 Florian Schmaus
|
||||
* Copyright 2018-2020 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -29,8 +29,13 @@ import java.util.List;
|
|||
import org.jivesoftware.smack.AbstractXMPPConnection;
|
||||
import org.jivesoftware.smack.ConnectionConfiguration;
|
||||
import org.jivesoftware.smack.XMPPConnection;
|
||||
import org.jivesoftware.smack.util.Consumer;
|
||||
|
||||
public class XmppConnectionDescriptor<C extends AbstractXMPPConnection, CC extends ConnectionConfiguration, CCB extends ConnectionConfiguration.Builder<?, CC>> {
|
||||
public final class XmppConnectionDescriptor<
|
||||
C extends AbstractXMPPConnection,
|
||||
CC extends ConnectionConfiguration,
|
||||
CCB extends ConnectionConfiguration.Builder<?, CC>
|
||||
> {
|
||||
|
||||
private final Class<C> connectionClass;
|
||||
private final Class<CC> connectionConfigurationClass;
|
||||
|
|
@ -38,13 +43,18 @@ public class XmppConnectionDescriptor<C extends AbstractXMPPConnection, CC exten
|
|||
private final Constructor<C> connectionConstructor;
|
||||
private final Method builderMethod;
|
||||
|
||||
public XmppConnectionDescriptor(Class<C> connectionClass, Class<CC> connectionConfigurationClass)
|
||||
throws ClassNotFoundException, NoSuchMethodException, SecurityException {
|
||||
this.connectionClass = connectionClass;
|
||||
this.connectionConfigurationClass = connectionConfigurationClass;
|
||||
private final Consumer<CCB> extraBuilder;
|
||||
|
||||
this.connectionConstructor = getConstructor(connectionClass, connectionConfigurationClass);
|
||||
this.builderMethod = getBuilderMethod(connectionConfigurationClass);
|
||||
private final String nickname;
|
||||
|
||||
private XmppConnectionDescriptor(Builder<C, CC, CCB> builder) throws NoSuchMethodException, SecurityException {
|
||||
connectionClass = builder.connectionClass;
|
||||
connectionConfigurationClass = builder.connectionConfigurationClass;
|
||||
extraBuilder = builder.extraBuilder;
|
||||
nickname = builder.nickname;
|
||||
|
||||
connectionConstructor = getConstructor(connectionClass, connectionConfigurationClass);
|
||||
builderMethod = getBuilderMethod(connectionConfigurationClass);
|
||||
}
|
||||
|
||||
public C construct(Configuration sinttestConfiguration)
|
||||
|
|
@ -65,6 +75,9 @@ public class XmppConnectionDescriptor<C extends AbstractXMPPConnection, CC exten
|
|||
Collection<ConnectionConfigurationBuilderApplier> customConnectionConfigurationAppliers)
|
||||
throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
|
||||
CCB connectionConfigurationBuilder = getNewBuilder();
|
||||
if (extraBuilder != null) {
|
||||
extraBuilder.accept(connectionConfigurationBuilder);
|
||||
}
|
||||
for (ConnectionConfigurationBuilderApplier customConnectionConfigurationApplier : customConnectionConfigurationAppliers) {
|
||||
customConnectionConfigurationApplier.applyConfigurationTo(connectionConfigurationBuilder);
|
||||
}
|
||||
|
|
@ -88,6 +101,10 @@ public class XmppConnectionDescriptor<C extends AbstractXMPPConnection, CC exten
|
|||
return connectionClass;
|
||||
}
|
||||
|
||||
public String getNickname() {
|
||||
return nickname;
|
||||
}
|
||||
|
||||
private static <C extends XMPPConnection> Constructor<C> getConstructor(Class<C> connectionClass,
|
||||
Class<? extends ConnectionConfiguration> connectionConfigurationClass)
|
||||
throws NoSuchMethodException, SecurityException {
|
||||
|
|
@ -106,4 +123,47 @@ public class XmppConnectionDescriptor<C extends AbstractXMPPConnection, CC exten
|
|||
}
|
||||
return builderMethod;
|
||||
}
|
||||
|
||||
public static <C extends AbstractXMPPConnection, CC extends ConnectionConfiguration, CCB extends ConnectionConfiguration.Builder<?, CC>>
|
||||
Builder<C, CC, CCB> buildWith(Class<C> connectionClass, Class<CC> connectionConfigurationClass) {
|
||||
return buildWith(connectionClass, connectionConfigurationClass, null);
|
||||
}
|
||||
|
||||
public static <C extends AbstractXMPPConnection, CC extends ConnectionConfiguration, CCB extends ConnectionConfiguration.Builder<?, CC>>
|
||||
Builder<C, CC, CCB> buildWith(Class<C> connectionClass, Class<CC> connectionConfigurationClass, Class<CCB> connectionConfigurationBuilderClass) {
|
||||
return new Builder<>(connectionClass, connectionConfigurationClass, connectionConfigurationBuilderClass);
|
||||
}
|
||||
|
||||
public static final class Builder<C extends AbstractXMPPConnection, CC extends ConnectionConfiguration, CCB extends ConnectionConfiguration.Builder<?, CC>> {
|
||||
private final Class<C> connectionClass;
|
||||
private final Class<CC> connectionConfigurationClass;
|
||||
|
||||
private Consumer<CCB> extraBuilder;
|
||||
|
||||
private String nickname;
|
||||
|
||||
// The connectionConfigurationBuilderClass merely exists for type-checking purposes.
|
||||
@SuppressWarnings("UnusedVariable")
|
||||
private Builder(Class<C> connectionClass, Class<CC> connectionConfigurationClass,
|
||||
Class<CCB> connectionConfigurationBuilderClass) {
|
||||
this.connectionClass = connectionClass;
|
||||
this.connectionConfigurationClass = connectionConfigurationClass;
|
||||
|
||||
nickname = connectionClass.getSimpleName();
|
||||
}
|
||||
|
||||
public Builder<C, CC, CCB> applyExtraConfguration(Consumer<CCB> extraBuilder) {
|
||||
this.extraBuilder = extraBuilder;
|
||||
return this;
|
||||
}
|
||||
|
||||
public Builder<C, CC, CCB> withNickname(String nickname) {
|
||||
this.nickname = nickname;
|
||||
return this;
|
||||
}
|
||||
|
||||
public XmppConnectionDescriptor<C, CC, CCB> build() throws NoSuchMethodException, SecurityException {
|
||||
return new XmppConnectionDescriptor<>(this);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2018-2019 Florian Schmaus
|
||||
* Copyright 2018-2020 Florian Schmaus
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
|
|
@ -27,7 +27,6 @@ import java.util.HashMap;
|
|||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.logging.Level;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
|
|
@ -38,9 +37,11 @@ import org.jivesoftware.smack.SmackException.NoResponseException;
|
|||
import org.jivesoftware.smack.SmackException.NotConnectedException;
|
||||
import org.jivesoftware.smack.XMPPException;
|
||||
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
|
||||
import org.jivesoftware.smack.c2s.ModularXmppClientToServerConnection;
|
||||
import org.jivesoftware.smack.c2s.ModularXmppClientToServerConnectionConfiguration;
|
||||
import org.jivesoftware.smack.compression.CompressionModuleDescriptor;
|
||||
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
|
||||
import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
|
||||
import org.jivesoftware.smack.tcp.XmppNioTcpConnection;
|
||||
import org.jivesoftware.smack.util.MultiMap;
|
||||
import org.jivesoftware.smack.util.StringUtils;
|
||||
|
||||
|
|
@ -54,55 +55,92 @@ import org.jxmpp.jid.impl.JidCreate;
|
|||
import org.jxmpp.jid.parts.Localpart;
|
||||
import org.jxmpp.stringprep.XmppStringprepException;
|
||||
|
||||
public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
||||
public class XmppConnectionManager {
|
||||
|
||||
private static final Logger LOGGER = Logger.getLogger(XmppConnectionManager.class.getName());
|
||||
|
||||
private static final Map<Class<? extends AbstractXMPPConnection>, XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>> CONNECTION_DESCRIPTORS = new ConcurrentHashMap<>();
|
||||
private static final XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> DEFAULT_CONNECTION_DESCRIPTOR;
|
||||
|
||||
private static final Map<String, XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>> NICKNAME_CONNECTION_DESCRIPTORS = new HashMap<>();
|
||||
|
||||
private static final MultiMap<
|
||||
Class<? extends AbstractXMPPConnection>,
|
||||
XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>
|
||||
> CONNECTION_DESCRIPTORS = new MultiMap<>();
|
||||
|
||||
static {
|
||||
try {
|
||||
addConnectionDescriptor(XmppNioTcpConnection.class, XMPPTCPConnectionConfiguration.class);
|
||||
addConnectionDescriptor(XMPPTCPConnection.class, XMPPTCPConnectionConfiguration.class);
|
||||
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException e) {
|
||||
DEFAULT_CONNECTION_DESCRIPTOR = XmppConnectionDescriptor.buildWith(XMPPTCPConnection.class, XMPPTCPConnectionConfiguration.class)
|
||||
.withNickname("tcp")
|
||||
.build();
|
||||
addConnectionDescriptor(DEFAULT_CONNECTION_DESCRIPTOR);
|
||||
|
||||
addConnectionDescriptor(
|
||||
XmppConnectionDescriptor.buildWith(ModularXmppClientToServerConnection.class, ModularXmppClientToServerConnectionConfiguration.class)
|
||||
.withNickname("modular")
|
||||
.build()
|
||||
);
|
||||
addConnectionDescriptor(
|
||||
XmppConnectionDescriptor.buildWith(ModularXmppClientToServerConnection.class, ModularXmppClientToServerConnectionConfiguration.class, ModularXmppClientToServerConnectionConfiguration.Builder.class)
|
||||
.withNickname("modular-nocompress")
|
||||
.applyExtraConfguration(cb -> cb.removeModule(CompressionModuleDescriptor.class))
|
||||
.build()
|
||||
);
|
||||
} catch (NoSuchMethodException | SecurityException e) {
|
||||
throw new AssertionError(e);
|
||||
}
|
||||
}
|
||||
|
||||
public static void addConnectionDescriptor(Class<? extends AbstractXMPPConnection> connectionClass,
|
||||
Class<? extends ConnectionConfiguration> connectionConfigurationClass) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
|
||||
XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor = new XmppConnectionDescriptor<>(
|
||||
connectionClass, connectionConfigurationClass);
|
||||
addConnectionDescriptor(connectionDescriptor);
|
||||
}
|
||||
|
||||
public static void addConnectionDescriptor(
|
||||
public static boolean addConnectionDescriptor(
|
||||
XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor) {
|
||||
String nickname = connectionDescriptor.getNickname();
|
||||
Class<? extends AbstractXMPPConnection> connectionClass = connectionDescriptor.getConnectionClass();
|
||||
CONNECTION_DESCRIPTORS.put(connectionClass, connectionDescriptor);
|
||||
|
||||
boolean alreadyExisted;
|
||||
synchronized (CONNECTION_DESCRIPTORS) {
|
||||
alreadyExisted = removeConnectionDescriptor(nickname);
|
||||
|
||||
CONNECTION_DESCRIPTORS.put(connectionClass, connectionDescriptor);
|
||||
NICKNAME_CONNECTION_DESCRIPTORS.put(connectionDescriptor.getNickname(), connectionDescriptor);
|
||||
}
|
||||
return alreadyExisted;
|
||||
}
|
||||
|
||||
public static void removeConnectionDescriptor(Class<? extends AbstractXMPPConnection> connectionClass) {
|
||||
CONNECTION_DESCRIPTORS.remove(connectionClass);
|
||||
public static boolean removeConnectionDescriptor(String nickname) {
|
||||
synchronized (CONNECTION_DESCRIPTORS) {
|
||||
XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor = NICKNAME_CONNECTION_DESCRIPTORS.remove(nickname);
|
||||
if (connectionDescriptor == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean removed = CONNECTION_DESCRIPTORS.removeOne(connectionDescriptor.getConnectionClass(), connectionDescriptor);
|
||||
assert removed;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private final XmppConnectionDescriptor<DC, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> defaultConnectionDescriptor;
|
||||
private final XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> defaultConnectionDescriptor;
|
||||
|
||||
private final Map<Class<? extends AbstractXMPPConnection>, XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>> connectionDescriptors = new HashMap<>(
|
||||
CONNECTION_DESCRIPTORS.size());
|
||||
private final Map<String, XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>> nicknameConnectionDescriptors;
|
||||
|
||||
private final SmackIntegrationTestFramework<?> sinttestFramework;
|
||||
private final MultiMap<
|
||||
Class<? extends AbstractXMPPConnection>,
|
||||
XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>
|
||||
> connectionDescriptors;
|
||||
|
||||
private final SmackIntegrationTestFramework sinttestFramework;
|
||||
private final Configuration sinttestConfiguration;
|
||||
private final String testRunId;
|
||||
|
||||
private final DC accountRegistrationConnection;
|
||||
private final AbstractXMPPConnection accountRegistrationConnection;
|
||||
private final ServiceAdministrationManager adminManager;
|
||||
private final AccountManager accountManager;
|
||||
|
||||
/**
|
||||
* One of the three main connections. The type of the main connections is the default connection type.
|
||||
*/
|
||||
DC conOne, conTwo, conThree;
|
||||
AbstractXMPPConnection conOne, conTwo, conThree;
|
||||
|
||||
/**
|
||||
* A pool of authenticated and free to use connections.
|
||||
|
|
@ -114,20 +152,25 @@ public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
|||
*/
|
||||
private final List<AbstractXMPPConnection> connections = new ArrayList<>();
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
XmppConnectionManager(SmackIntegrationTestFramework<?> sinttestFramework,
|
||||
Class<? extends DC> defaultConnectionClass)
|
||||
XmppConnectionManager(SmackIntegrationTestFramework sinttestFramework)
|
||||
throws SmackException, IOException, XMPPException, InterruptedException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
|
||||
synchronized (CONNECTION_DESCRIPTORS) {
|
||||
connectionDescriptors = CONNECTION_DESCRIPTORS.clone();
|
||||
nicknameConnectionDescriptors = new HashMap<>(NICKNAME_CONNECTION_DESCRIPTORS);
|
||||
}
|
||||
|
||||
this.sinttestFramework = sinttestFramework;
|
||||
this.sinttestConfiguration = sinttestFramework.config;
|
||||
this.testRunId = sinttestFramework.testRunResult.testRunId;
|
||||
|
||||
connectionDescriptors.putAll(CONNECTION_DESCRIPTORS);
|
||||
|
||||
defaultConnectionDescriptor = (XmppConnectionDescriptor<DC, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>) connectionDescriptors.get(
|
||||
defaultConnectionClass);
|
||||
if (defaultConnectionDescriptor == null) {
|
||||
throw new IllegalArgumentException("Could not find a connection descriptor for " + defaultConnectionClass);
|
||||
String configuredDefaultConnectionNickname = sinttestConfiguration.defaultConnectionNickname;
|
||||
if (configuredDefaultConnectionNickname != null) {
|
||||
defaultConnectionDescriptor = nicknameConnectionDescriptors.get(configuredDefaultConnectionNickname);
|
||||
if (defaultConnectionDescriptor == null) {
|
||||
throw new IllegalArgumentException("Could not find a connection descriptor for connection nickname '" + configuredDefaultConnectionNickname + "'");
|
||||
}
|
||||
} else {
|
||||
defaultConnectionDescriptor = DEFAULT_CONNECTION_DESCRIPTOR;
|
||||
}
|
||||
|
||||
switch (sinttestConfiguration.accountRegistration) {
|
||||
|
|
@ -157,11 +200,11 @@ public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
|||
}
|
||||
}
|
||||
|
||||
SmackIntegrationTestEnvironment<DC> prepareEnvironment() throws KeyManagementException, NoSuchAlgorithmException,
|
||||
SmackIntegrationTestEnvironment prepareEnvironment() throws KeyManagementException, NoSuchAlgorithmException,
|
||||
InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException,
|
||||
SmackException, IOException, XMPPException, InterruptedException {
|
||||
prepareMainConnections();
|
||||
return new SmackIntegrationTestEnvironment<DC>(conOne, conTwo, conThree,
|
||||
return new SmackIntegrationTestEnvironment(conOne, conTwo, conThree,
|
||||
sinttestFramework.testRunResult.testRunId, sinttestConfiguration, this);
|
||||
}
|
||||
|
||||
|
|
@ -169,9 +212,9 @@ public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
|||
IllegalAccessException, IllegalArgumentException, InvocationTargetException, SmackException, IOException,
|
||||
XMPPException, InterruptedException {
|
||||
final int mainAccountCount = AccountNum.values().length;
|
||||
List<DC> connections = new ArrayList<>(mainAccountCount);
|
||||
List<AbstractXMPPConnection> connections = new ArrayList<>(mainAccountCount);
|
||||
for (AccountNum mainAccountNum : AccountNum.values()) {
|
||||
DC mainConnection = getConnectedMainConnectionFor(mainAccountNum);
|
||||
AbstractXMPPConnection mainConnection = getConnectedMainConnectionFor(mainAccountNum);
|
||||
connections.add(mainConnection);
|
||||
}
|
||||
conOne = connections.get(0);
|
||||
|
|
@ -179,18 +222,18 @@ public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
|||
conThree = connections.get(2);
|
||||
}
|
||||
|
||||
public Class<? extends AbstractXMPPConnection> getDefaultConnectionClass() {
|
||||
return defaultConnectionDescriptor.getConnectionClass();
|
||||
public XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> getDefaultConnectionDescriptor() {
|
||||
return defaultConnectionDescriptor;
|
||||
}
|
||||
|
||||
public Set<Class<? extends AbstractXMPPConnection>> getConnectionClasses() {
|
||||
return Collections.unmodifiableSet(connectionDescriptors.keySet());
|
||||
public Collection<XmppConnectionDescriptor<? extends AbstractXMPPConnection, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>> getConnectionDescriptors() {
|
||||
return Collections.unmodifiableCollection(nicknameConnectionDescriptors.values());
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public <C extends AbstractXMPPConnection> XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> getConnectionDescriptorFor(
|
||||
Class<C> connectionClass) {
|
||||
return (XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>) connectionDescriptors.get(
|
||||
return (XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>) connectionDescriptors.getFirst(
|
||||
connectionClass);
|
||||
}
|
||||
|
||||
|
|
@ -249,7 +292,7 @@ public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
|||
|
||||
private static final String USERNAME_PREFIX = "smack-inttest";
|
||||
|
||||
private DC getConnectedMainConnectionFor(AccountNum accountNum) throws SmackException, IOException, XMPPException,
|
||||
private AbstractXMPPConnection getConnectedMainConnectionFor(AccountNum accountNum) throws SmackException, IOException, XMPPException,
|
||||
InterruptedException, KeyManagementException, NoSuchAlgorithmException, InstantiationException,
|
||||
IllegalAccessException, IllegalArgumentException, InvocationTargetException {
|
||||
String middlefix;
|
||||
|
|
@ -283,7 +326,7 @@ public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
|||
registerAccount(finalAccountUsername, finalAccountPassword);
|
||||
}
|
||||
|
||||
DC mainConnection = defaultConnectionDescriptor.construct(sinttestConfiguration, builder -> {
|
||||
AbstractXMPPConnection mainConnection = defaultConnectionDescriptor.construct(sinttestConfiguration, builder -> {
|
||||
try {
|
||||
builder.setUsernameAndPassword(finalAccountUsername, finalAccountPassword)
|
||||
.setResource(middlefix + '-' + testRunId);
|
||||
|
|
@ -347,7 +390,7 @@ public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
|||
|
||||
@SuppressWarnings("unchecked")
|
||||
XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor = (XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>>) connectionDescriptors
|
||||
.get(connectionClass);
|
||||
.getFirst(connectionClass);
|
||||
for (int i = 0; i < count; i++) {
|
||||
C connection = constructConnectedConnection(connectionDescriptor);
|
||||
connections.add(connection);
|
||||
|
|
@ -367,7 +410,7 @@ public class XmppConnectionManager<DC extends AbstractXMPPConnection> {
|
|||
return connection;
|
||||
}
|
||||
|
||||
DC constructConnection()
|
||||
AbstractXMPPConnection constructConnection()
|
||||
throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
|
||||
return constructConnection(defaultConnectionDescriptor);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue