SmackIntegrationTestFramework.java

  1. /**
  2.  *
  3.  * Copyright 2015-2023 Florian Schmaus
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.igniterealtime.smack.inttest;

  19. import static org.reflections.ReflectionUtils.getAllMethods;
  20. import static org.reflections.ReflectionUtils.withAnnotation;
  21. import static org.reflections.ReflectionUtils.withModifier;
  22. import static org.reflections.ReflectionUtils.withParametersCount;
  23. import static org.reflections.ReflectionUtils.withReturnType;

  25. import java.io.IOException;
  26. import java.lang.annotation.Annotation;
  27. import java.lang.reflect.Constructor;
  28. import java.lang.reflect.InvocationTargetException;
  29. import java.lang.reflect.Method;
  30. import java.lang.reflect.Modifier;
  31. import java.lang.reflect.ParameterizedType;
  32. import java.lang.reflect.Type;
  33. import java.security.KeyManagementException;
  34. import java.security.NoSuchAlgorithmException;
  35. import java.util.ArrayList;
  36. import java.util.Arrays;
  37. import java.util.Collection;
  38. import java.util.Collections;
  39. import java.util.HashMap;
  40. import java.util.HashSet;
  41. import java.util.Iterator;
  42. import java.util.LinkedList;
  43. import java.util.List;
  44. import java.util.Locale;
  45. import java.util.Map;
  46. import java.util.Set;
  47. import java.util.SortedSet;
  48. import java.util.TreeSet;
  49. import java.util.logging.Level;
  50. import java.util.logging.Logger;

  52. import org.jivesoftware.smack.AbstractXMPPConnection;
  53. import org.jivesoftware.smack.ConnectionConfiguration;
  54. import org.jivesoftware.smack.ConnectionConfiguration.SecurityMode;
  55. import org.jivesoftware.smack.Smack;
  56. import org.jivesoftware.smack.SmackConfiguration;
  57. import org.jivesoftware.smack.SmackException;
  58. import org.jivesoftware.smack.SmackException.NoResponseException;
  59. import org.jivesoftware.smack.SmackException.NotConnectedException;
  60. import org.jivesoftware.smack.XMPPException;
  61. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  62. import org.jivesoftware.smack.tcp.XMPPTCPConnectionConfiguration;
  63. import org.jivesoftware.smack.util.StringUtils;
  64. import org.jivesoftware.smack.util.TLSUtils;
  65. import org.jivesoftware.smack.util.dns.dnsjava.DNSJavaResolver;
  66. import org.jivesoftware.smack.util.dns.javax.JavaxResolver;
  67. import org.jivesoftware.smack.util.dns.minidns.MiniDnsResolver;

  69. import org.jivesoftware.smackx.debugger.EnhancedDebugger;
  70. import org.jivesoftware.smackx.debugger.EnhancedDebuggerWindow;
  71. import org.jivesoftware.smackx.iqregister.AccountManager;

  73. import org.igniterealtime.smack.inttest.Configuration.AccountRegistration;
  74. import org.igniterealtime.smack.inttest.annotations.AfterClass;
  75. import org.igniterealtime.smack.inttest.annotations.BeforeClass;
  76. import org.igniterealtime.smack.inttest.annotations.SmackIntegrationTest;
  77. import org.igniterealtime.smack.inttest.annotations.SpecificationReference;
  78. import org.reflections.Reflections;
  79. import org.reflections.scanners.MethodAnnotationsScanner;
  80. import org.reflections.scanners.MethodParameterScanner;
  81. import org.reflections.scanners.SubTypesScanner;
  82. import org.reflections.scanners.TypeAnnotationsScanner;

  84. public class SmackIntegrationTestFramework {

  86.     static {
  87.         TLSUtils.setDefaultTrustStoreTypeToJksIfRequired();
  88.     }

  90.     private static final Logger LOGGER = Logger.getLogger(SmackIntegrationTestFramework.class.getName());

  92.     public static boolean SINTTEST_UNIT_TEST = false;

  94.     private static ConcreteTest TEST_UNDER_EXECUTION;

  96.     protected final Configuration config;

  98.     protected TestRunResult testRunResult;

  100.     private SmackIntegrationTestEnvironment environment;
  101.     protected XmppConnectionManager connectionManager;

  103.     public enum TestType {
  104.         Normal,
  105.         LowLevel,
  106.         SpecificLowLevel,
  107.     }

  109.     public static void main(String[] args) throws IOException, KeyManagementException,
  110.             NoSuchAlgorithmException, SmackException, XMPPException, InterruptedException, InstantiationException,
  111.             IllegalAccessException, IllegalArgumentException, InvocationTargetException {
  112.         Configuration config = Configuration.newConfiguration(args);

  114.         SmackIntegrationTestFramework sinttest = new SmackIntegrationTestFramework(config);
  115.         TestRunResult testRunResult = sinttest.run();

  117.         for (final TestRunResultProcessor testRunResultProcessor : config.testRunResultProcessors) {
  118.             try {
  119.                 testRunResultProcessor.process(testRunResult);
  120.             } catch (Throwable t) {
  121.                 LOGGER.log(Level.WARNING, "Invocation of TestRunResultProcessor " + testRunResultProcessor + " failed.", t);
  122.             }
  123.         }

  125.         if (config.debuggerFactory instanceof EnhancedDebugger) {
  126.             EnhancedDebuggerWindow.getInstance().waitUntilClosed();
  127.         }

  129.         final int exitStatus = testRunResult.failedIntegrationTests.isEmpty() ? 0 : 2;
  130.         System.exit(exitStatus);
  131.     }

  133.     public static class JulTestRunResultProcessor implements TestRunResultProcessor {

  135.         @Override
  136.         public void process(final TestRunResult testRunResult) {
  137.             for (Map.Entry<Class<? extends AbstractSmackIntTest>, Throwable> entry : testRunResult.impossibleTestClasses.entrySet()) {
  138.                 LOGGER.info("Could not run " + entry.getKey().getName() + " because: "
  139.                     + entry.getValue().getLocalizedMessage());
  140.             }
  141.             for (TestNotPossible testNotPossible : testRunResult.impossibleIntegrationTests) {
  142.                 LOGGER.info("Could not run " + testNotPossible.concreteTest + " because: "
  143.                     + testNotPossible.testNotPossibleException.getMessage());
  144.             }
  145.             for (SuccessfulTest successfulTest : testRunResult.successfulIntegrationTests) {
  146.                 LOGGER.info(successfulTest.concreteTest + " ✔");
  147.             }
  148.             final int successfulTests = testRunResult.successfulIntegrationTests.size();
  149.             final int failedTests = testRunResult.failedIntegrationTests.size();
  150.             final int availableTests = testRunResult.getNumberOfAvailableTests();
  151.             LOGGER.info("SmackIntegrationTestFramework[" + testRunResult.testRunId + ']' + " finished: "
  152.                 + successfulTests + '/' + availableTests + " [" + failedTests + " failed]");

  154.             if (failedTests > 0) {
  155.                 LOGGER.warning("💀 The following " + failedTests + " tests failed! 💀");
  156.                 final SortedSet<String> bySpecification = new TreeSet<>();
  157.                 for (FailedTest failedTest : testRunResult.failedIntegrationTests) {
  158.                     final Throwable cause = failedTest.failureReason;
  159.                     LOGGER.log(Level.SEVERE, failedTest.concreteTest + " failed: " + cause, cause);
  160.                 if (failedTest.concreteTest.method.getDeclaringClass().isAnnotationPresent(SpecificationReference.class)) {
  161.                         final String specificationReference = getSpecificationReference(failedTest.concreteTest.method);
  162.                         if (specificationReference != null) {
  163.                             bySpecification.add("- " + specificationReference + " (as tested by '" + failedTest.concreteTest + "')");
  164.                         }
  165.                     }
  166.                 }
  167.                 if (!bySpecification.isEmpty()) {
  168.                     LOGGER.log(Level.SEVERE, "The failed tests correspond to the following specifications:" + System.lineSeparator() + String.join(System.lineSeparator(), bySpecification));
  169.                 }
  170.             } else {
  171.                 LOGGER.info("All possible Smack Integration Tests completed successfully. \\o/");
  172.             }
  173.         }
  174.     }

  176.     private static String getSpecificationReference(Method method) {
  177.         final SpecificationReference spec = method.getDeclaringClass().getAnnotation(SpecificationReference.class);
  178.         if (spec == null || spec.document().isBlank()) {
  179.             return null;
  180.         }
  181.         String line = spec.document().trim();
  182.         if (!spec.version().isBlank()) {
  183.             line += " (version " + spec.version() + ")";
  184.         }

  186.         final SmackIntegrationTest test = method.getAnnotation(SmackIntegrationTest.class);
  187.         if (!test.section().isBlank()) {
  188.             line += " section " + test.section().trim();
  189.         }
  190.         if (!test.quote().isBlank()) {
  191.             line += ":\t\"" + test.quote().trim() + "\"";
  192.         }
  193.         assert !line.isBlank();
  194.         return line;
  195.     }

  197.     public SmackIntegrationTestFramework(Configuration configuration) {
  198.         this.config = configuration;
  199.     }

  201.     public synchronized TestRunResult run()
  202.             throws KeyManagementException, NoSuchAlgorithmException, SmackException, IOException, XMPPException,
  203.             InterruptedException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
  204.         // The DNS resolver is not really a per sinttest run setting. It is not even a per connection setting. Instead
  205.         // it is a global setting, but we treat it like a per sinttest run setting.
  206.         switch (config.dnsResolver) {
  207.         case minidns:
  208.             MiniDnsResolver.setup();
  209.             break;
  210.         case javax:
  211.             JavaxResolver.setup();
  212.             break;
  213.         case dnsjava:
  214.             DNSJavaResolver.setup();
  215.             break;
  216.         }
  217.         testRunResult = new TestRunResult();

  219.         // Create a connection manager *after* we created the testRunId (in testRunResult).
  220.         this.connectionManager = new XmppConnectionManager(this);

  222.         LOGGER.info("SmackIntegrationTestFramework [" + testRunResult.testRunId + ']' + ": Starting\nSmack version: " + Smack.getVersion());
  223.         if (config.debuggerFactory != null) {
  224.             // JUL Debugger will not print any information until configured to print log messages of
  225.             // level FINE
  226.             // TODO configure JUL for log?
  227.             SmackConfiguration.addDisabledSmackClass("org.jivesoftware.smack.debugger.JulDebugger");
  228.             SmackConfiguration.DEBUG = true;
  229.         }
  230.         if (config.replyTimeout > 0) {
  231.             SmackConfiguration.setDefaultReplyTimeout(config.replyTimeout);
  232.         }
  233.         if (config.securityMode != SecurityMode.required && config.accountRegistration == AccountRegistration.inBandRegistration) {
  234.             AccountManager.sensitiveOperationOverInsecureConnectionDefault(true);
  235.         }
  236.         // TODO print effective configuration

  238.         String[] testPackages;
  239.         if (config.testPackages == null || config.testPackages.isEmpty()) {
  240.             testPackages = new String[] { "org.jivesoftware.smackx", "org.jivesoftware.smack", "org.igniterealtime.smackx", "org.igniterealtime.smack" };
  241.         }
  242.         else {
  243.             testPackages = config.testPackages.toArray(new String[config.testPackages.size()]);
  244.         }
  245.         Reflections reflections = new Reflections(testPackages, new SubTypesScanner(),
  246.                         new TypeAnnotationsScanner(), new MethodAnnotationsScanner(), new MethodParameterScanner());
  247.         Set<Class<? extends AbstractSmackIntegrationTest>> inttestClasses = reflections.getSubTypesOf(AbstractSmackIntegrationTest.class);
  248.         Set<Class<? extends AbstractSmackLowLevelIntegrationTest>> lowLevelInttestClasses = reflections.getSubTypesOf(AbstractSmackLowLevelIntegrationTest.class);

  250.         final int builtInTestCount = inttestClasses.size() + lowLevelInttestClasses.size();
  251.         Set<Class<? extends AbstractSmackIntTest>> classes = new HashSet<>(builtInTestCount);
  252.         classes.addAll(inttestClasses);
  253.         classes.addAll(lowLevelInttestClasses);

  255.         {
  256.             // Remove all abstract classes.
  257.             // TODO: This may be a good candidate for Java stream filtering once Smack is Android API 24 or higher.
  258.             Iterator<Class<? extends AbstractSmackIntTest>> it = classes.iterator();
  259.             while (it.hasNext()) {
  260.                 Class<? extends AbstractSmackIntTest> clazz = it.next();
  261.                 if (Modifier.isAbstract(clazz.getModifiers())) {
  262.                     it.remove();
  263.                 }
  264.             }
  265.         }

  267.         if (classes.isEmpty()) {
  268.             throw new IllegalStateException("No test classes in " + Arrays.toString(testPackages) + " found");
  269.         }

  271.         LOGGER.info("SmackIntegrationTestFramework [" + testRunResult.testRunId
  272.                         + "]: Finished scanning for tests, preparing environment\n"
  273.                         + "\tJava SE Platform version: " + Runtime.version());
  274.         environment = prepareEnvironment();

  276.         try {
  277.             runTests(classes);
  278.         }
  279.         catch (Throwable t) {
  280.             // Log the thrown Throwable to prevent it being shadowed in case the finally block below also throws.
  281.             LOGGER.log(Level.SEVERE, "Unexpected abort because runTests() threw throwable", t);
  282.             throw t;
  283.         }
  284.         finally {
  285.             // Ensure that the accounts are deleted and disconnected before we continue
  286.             connectionManager.disconnectAndCleanup();
  287.         }

  289.         return testRunResult;
  290.     }

  292.     public static ConcreteTest getTestUnderExecution() {
  293.         return TEST_UNDER_EXECUTION;
  294.     }

  296.     @SuppressWarnings({"Finally"})
  297.     private void runTests(Set<Class<? extends AbstractSmackIntTest>> classes)
  298.             throws InterruptedException, InstantiationException, IllegalAccessException,
  299.             IllegalArgumentException, SmackException, IOException, XMPPException {
  300.         List<PreparedTest> tests = new ArrayList<>(classes.size());
  301.         int numberOfAvailableTests = 0;

  303.         for (Class<? extends AbstractSmackIntTest> testClass : classes) {
  304.             final String testClassName = testClass.getName();

  306.             // TODO: Move the whole "skipping section" below one layer up?

  308.             // Skip pseudo integration tests from src/test
  309.             // Although Smack's gradle build files do not state that the 'main' sources classpath also contains the
  310.             // 'test' classes. Some IDEs like Eclipse include them. As result, a real integration test run encounters
  311.             // pseudo integration tests like the DummySmackIntegrationTest which always throws from src/test.
  312.             // It is unclear why this apparently does not happen in the 4.3 branch, one likely cause is
  313.             // compile project(path: ":smack-omemo", configuration: "testRuntime")
  314.             // in
  315.             // smack-integration-test/build.gradle:17
  316.             // added after 4.3 was branched out with
  317.             // 1f731f6318785a84b9741280d586a61dc37ecb2e
  318.             // Now "gradle integrationTest" appear to be never affected by this, i.e., they are executed with the
  319.             // correct classpath. Plain Eclipse, i.e. Smack imported into Eclipse after "gradle eclipse", appear
  320.             // to include *all* classes. Which means those runs sooner or later try to execute
  321.             // DummySmackIntegrationTest. Eclipse with buildship, the gradle plugin for Eclipse, always excludes
  322.             // *all* src/test classes, which means they do not encounter DummySmackIntegrationTest, but this means
  323.             // that the "compile project(path: ":smack-omemo", configuration: "testRuntime")" is not respected,
  324.             // which leads to
  325.             // Exception in thread "main" java.lang.NoClassDefFoundError: org/jivesoftware/smack/test/util/FileTestUtil
  326.             //   at org.jivesoftware.smackx.ox.OXSecretKeyBackupIntegrationTest.<clinit>(OXSecretKeyBackupIntegrationTest.java:66)
  327.             // See
  328.             // - https://github.com/eclipse/buildship/issues/354 (Remove test dependencies from runtime classpath)
  329.             // - https://bugs.eclipse.org/bugs/show_bug.cgi?id=482315 (Runtime classpath includes test dependencies)
  330.             // - https://discuss.gradle.org/t/main-vs-test-compile-vs-runtime-classpaths-in-eclipse-once-and-for-all-how/17403
  331.             // - https://bugs.eclipse.org/bugs/show_bug.cgi?id=376616 (Scope of dependencies has no effect on Eclipse compilation)
  332.             if (!SINTTEST_UNIT_TEST && testClassName.startsWith("org.igniterealtime.smack.inttest.unittest")) {
  333.                 LOGGER.warning("Skipping integration test '" + testClassName + "' from src/test classpath (should not be in classpath)");
  334.                 continue;
  335.             }

  337.             if (!config.isClassEnabled(testClass)) {
  338.                 DisabledTestClass disabledTestClass = new DisabledTestClass(testClass, "Skipping test class " + testClassName + " because it is not enabled");
  339.                 testRunResult.disabledTestClasses.add(disabledTestClass);
  340.                 continue;
  341.             }

  343.             if (config.isClassDisabled(testClass)) {
  344.                 DisabledTestClass disabledTestClass = new DisabledTestClass(testClass, "Skipping test class " + testClassName + " because it is disabled");
  345.                 testRunResult.disabledTestClasses.add(disabledTestClass);
  346.                 continue;
  347.             }

  349.             final String specification;
  350.             if (testClass.isAnnotationPresent(SpecificationReference.class)) {
  351.                 final SpecificationReference specificationReferenceAnnotation = testClass.getAnnotation(SpecificationReference.class);
  352.                 specification = Configuration.normalizeSpecification(specificationReferenceAnnotation.document());
  353.             } else {
  354.                 specification = null;
  355.             }

  357.             if (!config.isSpecificationEnabled(specification)) {
  358.                 DisabledTestClass disabledTestClass = new DisabledTestClass(testClass, "Skipping test method " + testClass + " because it tests a specification ('" + specification + "') that is not enabled");
  359.                 testRunResult.disabledTestClasses.add(disabledTestClass);
  360.                 continue;
  361.             }

  363.             if (config.isSpecificationDisabled(specification)) {
  364.                 DisabledTestClass disabledTestClass = new DisabledTestClass(testClass, "Skipping test method " + testClass + " because it tests a specification ('" + specification + "') that is disabled");
  365.                 testRunResult.disabledTestClasses.add(disabledTestClass);
  366.                 continue;
  367.             }

  369.             final Constructor<? extends AbstractSmackIntTest> cons;
  370.             try {
  371.                 cons = testClass.getConstructor(SmackIntegrationTestEnvironment.class);
  372.             }
  373.             catch (NoSuchMethodException | SecurityException e) {
  374.                 throw new IllegalArgumentException(
  375.                                 "Smack Integration Test class does not declare the correct constructor. Is a public Constructor(SmackIntegrationTestEnvironment) missing?",
  376.                                 e);
  377.             }

  379.             final List<Method> smackIntegrationTestMethods;
  380.             {
  381.                 Method[] testClassMethods = testClass.getMethods();
  382.                 smackIntegrationTestMethods = new ArrayList<>(testClassMethods.length);
  383.                 for (Method method : testClassMethods) {
  384.                     if (!method.isAnnotationPresent(SmackIntegrationTest.class)) {
  385.                         continue;
  386.                     }
  387.                     smackIntegrationTestMethods.add(method);
  388.                 }
  389.             }

  391.             if (smackIntegrationTestMethods.isEmpty()) {
  392.                 LOGGER.warning("No Smack integration test methods found in " + testClass);
  393.                 continue;
  394.             }

  396.             final AbstractSmackIntTest test;
  397.             try {
  398.                 test = cons.newInstance(environment);
  399.             }
  400.             catch (InvocationTargetException e) {
  401.                 Throwable cause = e.getCause();

  403.                 throwFatalException(cause);

  405.                 testRunResult.impossibleTestClasses.put(testClass, cause);
  406.                 continue;
  407.             }

  409.             XmppConnectionDescriptor<?, ?, ?> specificLowLevelConnectionDescriptor = null;
  410.             final TestType testType;
  411.             if (test instanceof AbstractSmackSpecificLowLevelIntegrationTest) {
  412.                 AbstractSmackSpecificLowLevelIntegrationTest<?> specificLowLevelTest = (AbstractSmackSpecificLowLevelIntegrationTest<?>) test;
  413.                 specificLowLevelConnectionDescriptor = specificLowLevelTest.getConnectionDescriptor();
  414.                 testType = TestType.SpecificLowLevel;
  415.             } else if (test instanceof AbstractSmackLowLevelIntegrationTest) {
  416.                 testType = TestType.LowLevel;
  417.             } else if (test instanceof AbstractSmackIntegrationTest) {
  418.                 testType = TestType.Normal;
  419.             } else {
  420.                 throw new AssertionError();
  421.             }

  423.             // Verify the method signatures, throw in case a signature is incorrect.
  424.             for (Method method : smackIntegrationTestMethods) {
  425.                 Class<?> retClass = method.getReturnType();
  426.                 if (!retClass.equals(Void.TYPE)) {
  427.                     throw new IllegalStateException(
  428.                             "SmackIntegrationTest annotation on" + method + " that does not return void");
  429.                 }
  430.                 switch (testType) {
  431.                 case Normal:
  432.                     final Class<?>[] parameterTypes = method.getParameterTypes();
  433.                     if (parameterTypes.length > 0) {
  434.                         throw new IllegalStateException(
  435.                                 "SmackIntegrationTest annotation on " + method + " that takes arguments ");
  436.                     }
  437.                     break;
  438.                 case LowLevel:
  439.                     verifyLowLevelTestMethod(method, AbstractXMPPConnection.class);
  440.                     break;
  441.                 case SpecificLowLevel:
  442.                     Class<? extends AbstractXMPPConnection> specificLowLevelConnectionClass = specificLowLevelConnectionDescriptor.getConnectionClass();
  443.                     verifyLowLevelTestMethod(method, specificLowLevelConnectionClass);
  444.                     break;
  445.                 }
  446.             }

  448.             Iterator<Method> it = smackIntegrationTestMethods.iterator();
  449.             while (it.hasNext()) {
  450.                 final Method method = it.next();
  451.                 final String methodName = method.getName();
  452.                 if (!config.isMethodEnabled(method)) {
  453.                     DisabledTest disabledTest = new DisabledTest(method, "Skipping test method " + methodName + " because it is not enabled");
  454.                     testRunResult.disabledTests.add(disabledTest);
  455.                     it.remove();
  456.                     continue;
  457.                 }
  458.                 if (config.isMethodDisabled(method)) {
  459.                     DisabledTest disabledTest = new DisabledTest(method, "Skipping test method " + methodName + " because it is disabled");
  460.                     testRunResult.disabledTests.add(disabledTest);
  461.                     it.remove();
  462.                     continue;
  463.                 }
  464.             }

  466.             if (smackIntegrationTestMethods.isEmpty()) {
  467.                 LOGGER.info("All tests in " + testClassName + " are disabled");
  468.                 continue;
  469.             }

  471.             List<ConcreteTest> concreteTests = new ArrayList<>(smackIntegrationTestMethods.size());

  473.             for (Method testMethod : smackIntegrationTestMethods) {
  474.                 switch (testType) {
  475.                 case Normal: {
  476.                     ConcreteTest.Executor concreteTestExecutor = () -> testMethod.invoke(test);
  477.                     ConcreteTest concreteTest = new ConcreteTest(testType, testMethod, concreteTestExecutor);
  478.                     concreteTests.add(concreteTest);
  479.                 }
  480.                     break;
  481.                 case LowLevel:
  482.                 case SpecificLowLevel:
  483.                     LowLevelTestMethod lowLevelTestMethod = new LowLevelTestMethod(testMethod);
  484.                     switch (testType) {
  485.                     case LowLevel:
  486.                         List<ConcreteTest> concreteLowLevelTests = invokeLowLevel(lowLevelTestMethod, (AbstractSmackLowLevelIntegrationTest) test);
  487.                         concreteTests.addAll(concreteLowLevelTests);
  488.                         break;
  489.                     case SpecificLowLevel: {
  490.                         ConcreteTest.Executor concreteTestExecutor = () -> invokeSpecificLowLevel(
  491.                                 lowLevelTestMethod, (AbstractSmackSpecificLowLevelIntegrationTest<?>) test);
  492.                         ConcreteTest concreteTest = new ConcreteTest(testType, testMethod, concreteTestExecutor);
  493.                         concreteTests.add(concreteTest);
  494.                         break;
  495.                     }
  496.                     default:
  497.                         throw new AssertionError();
  498.                     }
  499.                     break;
  500.                 }
  501.             }

  503.             // Instantiate the prepared test early as this will check the before and after class annotations.
  504.             PreparedTest preparedTest = new PreparedTest(test, concreteTests);
  505.             tests.add(preparedTest);

  507.             numberOfAvailableTests += concreteTests.size();
  508.         }

  510.         // Print status information.
  511.         StringBuilder sb = new StringBuilder(1024);
  512.         sb.append("Smack Integration Test Framework\n");
  513.         sb.append("################################\n");
  514.         if (config.verbose) {
  515.             sb.append('\n');
  516.             if (!testRunResult.disabledTestClasses.isEmpty()) {
  517.                 sb.append("The following test classes are disabled:\n");
  518.                 for (DisabledTestClass disabledTestClass : testRunResult.disabledTestClasses) {
  519.                     disabledTestClass.appendTo(sb).append('\n');
  520.                 }
  521.             }
  522.             if (!testRunResult.disabledTests.isEmpty()) {
  523.                 sb.append("The following tests are disabled:\n");
  524.                 for (DisabledTest disabledTest : testRunResult.disabledTests) {
  525.                     disabledTest.appendTo(sb).append('\n');
  526.                 }
  527.             }
  528.             sb.append('\n');
  529.         }

  531.         if (numberOfAvailableTests == 0) {
  532.             throw new IllegalArgumentException("No integration tests selected.");
  533.         }

  535.         sb.append("Available tests: ").append(numberOfAvailableTests);
  536.         if (!testRunResult.disabledTestClasses.isEmpty() || !testRunResult.disabledTests.isEmpty()) {
  537.             sb.append(" (Disabled ").append(testRunResult.disabledTestClasses.size()).append(" classes")
  538.               .append(" and ").append(testRunResult.disabledTests.size()).append(" tests)");
  539.         }
  540.         sb.append('\n');
  541.         LOGGER.info(sb.toString());

  543.         for (PreparedTest test : tests) {
  544.             test.run();
  545.         }

  547.         // Assert that all tests in the 'tests' list produced a result.
  548.         assert numberOfAvailableTests == testRunResult.getNumberOfAvailableTests();
  549.     }

  551.     private void runConcreteTest(ConcreteTest concreteTest)
  552.             throws InterruptedException, XMPPException, IOException, SmackException {
  553.         LOGGER.info(concreteTest + " Start");
  554.         long testStart = System.currentTimeMillis();
  555.         try {
  556.             concreteTest.executor.execute();
  557.             long testEnd = System.currentTimeMillis();
  558.             LOGGER.info(concreteTest + " Success");
  559.             testRunResult.successfulIntegrationTests.add(new SuccessfulTest(concreteTest, testStart, testEnd, null));
  560.         }
  561.         catch (InvocationTargetException e) {
  562.             long testEnd = System.currentTimeMillis();
  563.             Throwable cause = e.getCause();
  564.             if (cause instanceof TestNotPossibleException) {
  565.                 LOGGER.info(concreteTest + " is not possible");
  566.                 testRunResult.impossibleIntegrationTests.add(new TestNotPossible(concreteTest, testStart, testEnd,
  567.                                 null, (TestNotPossibleException) cause));
  568.                 return;
  569.             }
  570.             Throwable nonFatalFailureReason;
  571.             // junit asserts throw an AssertionError if they fail, those should not be
  572.             // thrown up, as it would be done by throwFatalException()
  573.             if (cause instanceof AssertionError) {
  574.                 nonFatalFailureReason = cause;
  575.             } else {
  576.                 nonFatalFailureReason = throwFatalException(cause);
  577.             }
  578.             // An integration test failed
  579.             testRunResult.failedIntegrationTests.add(new FailedTest(concreteTest, testStart, testEnd, null,
  580.                             nonFatalFailureReason));
  581.             LOGGER.log(Level.SEVERE, concreteTest + " Failed", e);
  582.         }
  583.         catch (IllegalArgumentException | IllegalAccessException e) {
  584.             throw new AssertionError(e);
  585.         }
  586.     }

  588.     private static void verifyLowLevelTestMethod(Method method,
  589.                     Class<? extends AbstractXMPPConnection> connectionClass) {
  590.         if (determineTestMethodParameterType(method, connectionClass) != null) {
  591.             return;
  592.         }

  594.         throw new IllegalArgumentException(method + " is not a valid low level test method");
  595.     }

  597.     private List<ConcreteTest> invokeLowLevel(LowLevelTestMethod lowLevelTestMethod, AbstractSmackLowLevelIntegrationTest test) {
  598.         Collection<? extends XmppConnectionDescriptor<?, ?, ?>> connectionDescriptors;
  599.         if (lowLevelTestMethod.smackIntegrationTestAnnotation.onlyDefaultConnectionType()) {
  600.             XmppConnectionDescriptor<?, ?, ?> defaultConnectionDescriptor = connectionManager.getDefaultConnectionDescriptor();
  601.             connectionDescriptors = Collections.singleton(defaultConnectionDescriptor);
  602.         } else {
  603.             connectionDescriptors = connectionManager.getConnectionDescriptors();
  604.         }

  606.         List<ConcreteTest> resultingConcreteTests = new ArrayList<>(connectionDescriptors.size());

  608.         for (XmppConnectionDescriptor<?, ?, ?> connectionDescriptor : connectionDescriptors) {
  609.             String connectionNick = connectionDescriptor.getNickname();

  611.             if (config.enabledConnections != null && !config.enabledConnections.contains(connectionNick)) {
  612.                 DisabledTest disabledTest = new DisabledTest(lowLevelTestMethod.testMethod, "Not creating test for " + lowLevelTestMethod + " with connection '" + connectionNick
  613.                                 + "', as this connection type is not enabled");
  614.                 testRunResult.disabledTests.add(disabledTest);
  615.                 continue;
  616.             }

  618.             if (config.disabledConnections != null && config.disabledConnections.contains(connectionNick)) {
  619.                 DisabledTest disabledTest = new DisabledTest(lowLevelTestMethod.testMethod, "Not creating test for " + lowLevelTestMethod + " with connection '" + connectionNick
  620.                                 + ", as this connection type is disabled");
  621.                 testRunResult.disabledTests.add(disabledTest);
  622.                 continue;
  623.             }

  625.             ConcreteTest.Executor executor = () -> lowLevelTestMethod.invoke(test, connectionDescriptor);
  626.             ConcreteTest concreteTest = new ConcreteTest(TestType.LowLevel, lowLevelTestMethod.testMethod, executor, connectionDescriptor.getNickname());
  627.             resultingConcreteTests.add(concreteTest);
  628.         }

  630.         return resultingConcreteTests;
  631.     }

  633.     private static <C extends AbstractXMPPConnection> void invokeSpecificLowLevel(LowLevelTestMethod testMethod,
  634.             AbstractSmackSpecificLowLevelIntegrationTest<C> test)
  635.             throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InterruptedException,
  636.             SmackException, IOException, XMPPException {
  637.         if (testMethod.smackIntegrationTestAnnotation.onlyDefaultConnectionType()) {
  638.             throw new IllegalArgumentException("SpecificLowLevelTests must not have set onlyDefaultConnectionType");
  639.         }

  641.         XmppConnectionDescriptor<C, ? extends ConnectionConfiguration, ? extends ConnectionConfiguration.Builder<?, ?>> connectionDescriptor = test.getConnectionDescriptor();
  642.         testMethod.invoke(test, connectionDescriptor);
  643.     }

  645.     protected SmackIntegrationTestEnvironment prepareEnvironment() throws SmackException,
  646.                     IOException, XMPPException, InterruptedException, KeyManagementException,
  647.                     NoSuchAlgorithmException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
  648.         return connectionManager.prepareEnvironment();
  649.     }

  651.     enum AccountNum {
  652.         One,
  653.         Two,
  654.         Three,
  655.     }

  657.     static XMPPTCPConnectionConfiguration.Builder getConnectionConfigurationBuilder(Configuration config) {
  658.         XMPPTCPConnectionConfiguration.Builder builder = XMPPTCPConnectionConfiguration.builder();

  660.         config.configurationApplier.applyConfigurationTo(builder);

  662.         return builder;
  663.     }

  665.     private static Exception throwFatalException(Throwable e) throws Error, NoResponseException,
  666.                     InterruptedException {
  667.         if (e instanceof InterruptedException) {
  668.             throw (InterruptedException) e;
  669.         }

  671.         // We handle NullPointerException as a non-fatal exception, as they are mostly caused by an invalid reply where
  672.         // an extension element is missing. Consider for example
  673.         // assertEquals(StanzaError.Condition.foo, response.getError().getCondition())
  674.         // Otherwise NPEs could be caused by an internal bug in Smack, e.g. missing null handling.
  675.         if (e instanceof NullPointerException) {
  676.             return (NullPointerException) e;
  677.         }
  678.         if (e instanceof RuntimeException) {
  679.             throw (RuntimeException) e;
  680.         }
  681.         if (e instanceof Error) {
  682.             throw (Error) e;
  683.         }
  684.         return (Exception) e;
  685.     }

  687.     @FunctionalInterface
  688.     public interface TestRunResultProcessor {
  689.         void process(SmackIntegrationTestFramework.TestRunResult testRunResult);
  690.     }

  692.     public static final class TestRunResult {

  694.         /**
  695.          * A short String of lowercase characters and numbers used to identify an integration test
  696.          * run. We use lowercase characters because this string will eventually be part of the
  697.          * localpart of the used JIDs (and the localpart is case-insensitive).
  698.          */
  699.         public final String testRunId = StringUtils.insecureRandomString(5).toLowerCase(Locale.US);

  701.         private final List<SuccessfulTest> successfulIntegrationTests = Collections.synchronizedList(new LinkedList<SuccessfulTest>());
  702.         private final List<FailedTest> failedIntegrationTests = Collections.synchronizedList(new LinkedList<FailedTest>());
  703.         private final List<TestNotPossible> impossibleIntegrationTests = Collections.synchronizedList(new LinkedList<TestNotPossible>());

  705.         // TODO: Ideally three would only be a list of disabledTests, but since we do not process a disabled test class
  706.         // any further, we can not determine the concrete disabled tests.
  707.         private final List<DisabledTestClass> disabledTestClasses = Collections.synchronizedList(new ArrayList<>());
  708.         private final List<DisabledTest> disabledTests = Collections.synchronizedList(new ArrayList<>());

  710.         private final Map<Class<? extends AbstractSmackIntTest>, Throwable> impossibleTestClasses = new HashMap<>();

  712.         TestRunResult() {
  713.         }

  715.         public String getTestRunId() {
  716.             return testRunId;
  717.         }

  719.         public int getNumberOfAvailableTests() {
  720.             return successfulIntegrationTests.size() + failedIntegrationTests.size() + impossibleIntegrationTests.size();
  721.         }

  723.         public List<SuccessfulTest> getSuccessfulTests() {
  724.             return Collections.unmodifiableList(successfulIntegrationTests);
  725.         }

  727.         public List<FailedTest> getFailedTests() {
  728.             return Collections.unmodifiableList(failedIntegrationTests);
  729.         }

  731.         public List<TestNotPossible> getNotPossibleTests() {
  732.             return Collections.unmodifiableList(impossibleIntegrationTests);
  733.         }

  735.         public Map<Class<? extends AbstractSmackIntTest>, Throwable> getImpossibleTestClasses() {
  736.             return Collections.unmodifiableMap(impossibleTestClasses);
  737.         }
  738.     }

  740.     final class PreparedTest {
  741.         private final AbstractSmackIntTest test;
  742.         private final List<ConcreteTest> concreteTests;

  744.         private final Method beforeClassMethod;
  745.         private final Method afterClassMethod;

  747.         private PreparedTest(AbstractSmackIntTest test, List<ConcreteTest> concreteTests) {
  748.             this.test = test;
  749.             this.concreteTests = concreteTests;
  750.             Class<? extends AbstractSmackIntTest> testClass = test.getClass();

  752.             beforeClassMethod = getSinttestSpecialMethod(testClass, BeforeClass.class);
  753.             afterClassMethod = getSinttestSpecialMethod(testClass, AfterClass.class);
  754.         }

  756.         public void run() throws InterruptedException, XMPPException, IOException, SmackException {
  757.             try {
  758.                 // Run the @BeforeClass methods (if any)
  759.                 executeSinttestSpecialMethod(beforeClassMethod);

  761.                 for (ConcreteTest concreteTest : concreteTests) {
  762.                     TEST_UNDER_EXECUTION = concreteTest;
  763.                     try {
  764.                         runConcreteTest(concreteTest);
  765.                     } finally {
  766.                         TEST_UNDER_EXECUTION = null;
  767.                     }
  768.                 }
  769.             }
  770.             finally {
  771.                 executeSinttestSpecialMethod(afterClassMethod);
  772.             }
  773.         }

  775.         private void executeSinttestSpecialMethod(Method method) {
  776.             if (method == null) {
  777.                 return;
  778.             }

  780.             try {
  781.                 method.invoke(test);
  782.             }
  783.             catch (InvocationTargetException | IllegalAccessException e) {
  784.                 LOGGER.log(Level.SEVERE, "Exception executing " + method, e);
  785.             }
  786.             catch (IllegalArgumentException e) {
  787.                 throw new AssertionError(e);
  788.             }
  789.         }
  790.     }

  792.     @SuppressWarnings("unchecked")
  793.     private static Method getSinttestSpecialMethod(Class<? extends AbstractSmackIntTest> testClass, Class<? extends Annotation> annotation) {
  794.         Set<Method> specialClassMethods = getAllMethods(testClass,
  795.                         withAnnotation(annotation), withReturnType(Void.TYPE),
  796.                         withParametersCount(0), withModifier(Modifier.PUBLIC
  797.                                         ));

  799.         // See if there are any methods that have a special but a wrong signature
  800.         Set<Method> allSpecialClassMethods = getAllMethods(testClass, withAnnotation(annotation));
  801.         allSpecialClassMethods.removeAll(specialClassMethods);
  802.         if (!allSpecialClassMethods.isEmpty()) {
  803.             throw new IllegalArgumentException(annotation + " methods with wrong signature found");
  804.         }

  806.         if (specialClassMethods.size() == 1) {
  807.             return specialClassMethods.iterator().next();
  808.         }
  809.         else if (specialClassMethods.size() > 1) {
  810.             throw new IllegalArgumentException("Only one @BeforeClass method allowed");
  811.         }

  813.         return null;
  814.     }

  816.     public static final class ConcreteTest {
  817.         private final TestType testType;
  818.         private final Method method;
  819.         private final Executor executor;
  820.         private final List<String> subdescriptons;

  822.         private ConcreteTest(TestType testType, Method method, Executor executor, String... subdescriptions) {
  823.             this.testType = testType;
  824.             this.method = method;
  825.             this.executor = executor;
  826.             this.subdescriptons = List.of(subdescriptions);
  827.         }

  829.         private transient String stringCache;

  831.         public TestType getTestType() {
  832.             return testType;
  833.         }

  835.         public Method getMethod() {
  836.             return method;
  837.         }

  839.         public List<String> getSubdescriptons() {
  840.             return subdescriptons;
  841.         }

  843.         @Override
  844.         public String toString() {
  845.             if (stringCache != null) {
  846.                 return stringCache;
  847.             }

  849.             StringBuilder sb = new StringBuilder();
  850.             sb.append(method.getDeclaringClass().getSimpleName())
  851.                 .append('.')
  852.                 .append(method.getName())
  853.                 .append(" (")
  854.                 .append(testType.name());
  855.             if (!subdescriptons.isEmpty()) {
  856.                 sb.append(", ");
  857.                 StringUtils.appendTo(subdescriptons, sb);
  858.             }
  859.             sb.append(')');

  861.             stringCache = sb.toString();
  862.             return stringCache;
  863.         }

  865.         private interface Executor {

  867.             /**
  868.              * Execute the test.
  869.              *
  870.              * @throws IllegalAccessException if there was an illegal access.
  871.              * @throws InterruptedException if the calling thread was interrupted.
  872.              * @throws InvocationTargetException if the reflective invoked test throws an exception.
  873.              * @throws XMPPException in case an XMPPException happens when <em>preparing</em> the test.
  874.              * @throws IOException in case an IOException happens when <em>preparing</em> the test.
  875.              * @throws SmackException in case an SmackException happens when <em>preparing</em> the test.
  876.              */
  877.             void execute() throws IllegalAccessException, InterruptedException, InvocationTargetException,
  878.                     XMPPException, IOException, SmackException;
  879.         }
  880.     }

  882.     public static final class DisabledTestClass {
  883.         private final Class<? extends AbstractSmackIntTest> testClass;
  884.         private final String reason;

  886.         private DisabledTestClass(Class<? extends AbstractSmackIntTest> testClass, String reason) {
  887.             this.testClass = testClass;
  888.             this.reason = reason;
  889.         }

  891.         public Class<? extends AbstractSmackIntTest> getTestClass() {
  892.             return testClass;
  893.         }

  895.         public String getReason() {
  896.             return reason;
  897.         }

  899.         public StringBuilder appendTo(StringBuilder sb) {
  900.             return sb.append("Disabled ").append(testClass).append(" because ").append(reason);
  901.         }
  902.     }

  904.     public static final class DisabledTest {
  905.         private final Method method;
  906.         private final String reason;

  908.         private DisabledTest(Method method, String reason) {
  909.             this.method = method;
  910.             this.reason = reason;
  911.         }

  913.         public Method getMethod() {
  914.             return method;
  915.         }

  917.         public String getReason() {
  918.             return reason;
  919.         }

  921.         public StringBuilder appendTo(StringBuilder sb) {
  922.             return sb.append("Disabled ").append(method).append(" because ").append(reason);
  923.         }
  924.     }

  926.     private final class LowLevelTestMethod {

  928.         private final Method testMethod;
  929.         private final SmackIntegrationTest smackIntegrationTestAnnotation;
  930.         private final TestMethodParameterType parameterType;

  932.         private LowLevelTestMethod(Method testMethod) {
  933.             this.testMethod = testMethod;

  935.             smackIntegrationTestAnnotation = testMethod.getAnnotation(SmackIntegrationTest.class);
  936.             assert smackIntegrationTestAnnotation != null;
  937.             parameterType = determineTestMethodParameterType(testMethod);
  938.         }

  940.         private void invoke(AbstractSmackLowLevelIntegrationTest test,
  941.                         XmppConnectionDescriptor<?, ?, ?> connectionDescriptor)
  942.                         throws IllegalAccessException, IllegalArgumentException, InvocationTargetException,
  943.                         InterruptedException, SmackException, IOException, XMPPException {
  944.             switch (parameterType) {
  945.             case singleConnectedConnection:
  946.             case collectionOfConnections:
  947.             case parameterListOfConnections:
  948.                 final boolean collectionOfConnections = parameterType == TestMethodParameterType.collectionOfConnections;

  950.                 final int connectionCount;
  951.                 if (collectionOfConnections) {
  952.                     connectionCount = smackIntegrationTestAnnotation.connectionCount();
  953.                     if (connectionCount < 1) {
  954.                         throw new IllegalArgumentException(testMethod + " is annotated to use less than one connection ('"
  955.                                         + connectionCount + ')');
  956.                     }
  957.                 } else {
  958.                     connectionCount = testMethod.getParameterCount();
  959.                 }

  961.                 List<? extends AbstractXMPPConnection> connections = connectionManager.constructConnectedConnections(
  962.                                 connectionDescriptor, connectionCount);

  964.                 if (collectionOfConnections) {
  965.                     testMethod.invoke(test, connections);
  966.                 } else {
  967.                     Object[] connectionsArray = new Object[connectionCount];
  968.                     for (int i = 0; i < connectionsArray.length; i++) {
  969.                         connectionsArray[i] = connections.remove(0);
  970.                     }
  971.                     testMethod.invoke(test, connectionsArray);
  972.                 }

  974.                 connectionManager.recycle(connections);
  975.                 break;
  976.             case unconnectedConnectionSource:
  977.                 AbstractSmackLowLevelIntegrationTest.UnconnectedConnectionSource source = () -> {
  978.                     try {
  979.                         return environment.connectionManager.constructConnection(connectionDescriptor);
  980.                     } catch (NoResponseException | XMPPErrorException | NotConnectedException
  981.                                     | InterruptedException e) {
  982.                         // TODO: Ideally we would wrap the exceptions in an unchecked exceptions, catch those unchecked
  983.                         // exceptions below and throw the wrapped checked exception.
  984.                         throw new RuntimeException(e);
  985.                     }
  986.                 };
  987.                 testMethod.invoke(test, source);
  988.                 break;
  989.             case noParamSpecificLowLevel:
  990.                 testMethod.invoke(test);
  991.                 break;
  992.             }
  993.         }

  995.         @Override
  996.         public String toString() {
  997.             return testMethod.toString();
  998.         }
  999.     }

  1001.     enum TestMethodParameterType {
  1002.         /**
  1003.          * testMethod(Connection connection)
  1004.          */
  1005.         singleConnectedConnection,

  1007.         /**
  1008.          * testMethod(Collection&lt;Connection&gt;)
  1009.          * <p> It can also be a subclass of collection like List. In fact, the type of the parameter being List is expected to be the common case.
  1010.          */
  1011.         collectionOfConnections,

  1013.         /**
  1014.          * testMethod(Connection a, Connection b, Connection c)
  1015.          */
  1016.         parameterListOfConnections,

  1018.         /**
  1019.          * testMethod(UnconnectedConnectionSource unconnectedConnectionSource)
  1020.          */
  1021.         unconnectedConnectionSource,

  1023.         /**
  1024.          * A no-parameter method of a {@link AbstractSmackSpecificLowLevelIntegrationTest}.
  1025.          */
  1026.         noParamSpecificLowLevel,
  1027.     };

  1029.     static TestMethodParameterType determineTestMethodParameterType(Method testMethod) {
  1030.         return determineTestMethodParameterType(testMethod, AbstractXMPPConnection.class);
  1031.     }

  1033.     static TestMethodParameterType determineTestMethodParameterType(Method testMethod, Class<? extends AbstractXMPPConnection> connectionClass) {
  1034.         Class<?>[] parameterTypes = testMethod.getParameterTypes();
  1035.         if (parameterTypes.length == 0) {
  1036.             if (AbstractSmackSpecificLowLevelIntegrationTest.class.isAssignableFrom(testMethod.getDeclaringClass())) {
  1037.                 return TestMethodParameterType.noParamSpecificLowLevel;
  1038.             }
  1039.             return null;
  1040.         }

  1042.         if (parameterTypes.length > 1) {
  1043.             // If there are more parameters, then all must be assignable from the connection class.
  1044.             for (Class<?> parameterType : parameterTypes) {
  1045.                 if (!connectionClass.isAssignableFrom(parameterType)) {
  1046.                     return null;
  1047.                 }
  1048.             }

  1050.             return TestMethodParameterType.parameterListOfConnections;
  1051.         }

  1053.         // This method has exactly a single parameter.
  1054.         Class<?> soleParameter = parameterTypes[0];

  1056.         if (Collection.class.isAssignableFrom(soleParameter)) {
  1057.             // The sole parameter is assignable from collection, which means that it is a parameterized generic type.
  1058.             ParameterizedType soleParameterizedType = (ParameterizedType) testMethod.getGenericParameterTypes()[0];
  1059.             Type[] actualTypeArguments = soleParameterizedType.getActualTypeArguments();
  1060.             if (actualTypeArguments.length != 1) {
  1061.                 // The parameter list of the Collection has more than one type.
  1062.                 return null;
  1063.             }

  1065.             Type soleActualTypeArgument = actualTypeArguments[0];
  1066.             if (!(soleActualTypeArgument instanceof Class<?>)) {
  1067.                 return null;
  1068.             }

  1070.             Class<?> soleActualTypeArgumentAsClass = (Class<?>) soleActualTypeArgument;
  1071.             if (!connectionClass.isAssignableFrom(soleActualTypeArgumentAsClass)) {
  1072.                 return null;
  1073.             }

  1075.             return TestMethodParameterType.collectionOfConnections;
  1076.         } else if (connectionClass.isAssignableFrom(soleParameter)) {
  1077.             return TestMethodParameterType.singleConnectedConnection;
  1078.         } else if (AbstractSmackLowLevelIntegrationTest.UnconnectedConnectionSource.class.isAssignableFrom(soleParameter)) {
  1079.             return TestMethodParameterType.unconnectedConnectionSource;
  1080.         }

  1082.         return null;
  1083.     }

  1085. }
Created with JaCoCo 0.8.6.202009150832