Re-wording the JVM arg name for better clarity.

Author: krmahadevan

testng-core-api/src/main/java/org/testng/internal/RuntimeBehavior.java

@@ -19,17 +19,22 @@ public final class RuntimeBehavior {
   public static final String TESTNG_DEFAULT_VERBOSE = "testng.default.verbose";
   public static final String IGNORE_CALLBACK_INVOCATION_SKIPS = "testng.ignore.callback.skip";
   public static final String SYMMETRIC_LISTENER_EXECUTION = "testng.listener.execution.symmetric";
-  public static final String IDE_PACKAGE_NAMES = "testng.ide.listeners.package.name";
+  public static final String PREFERENTIAL_LISTENERS = "testng.preferential.listeners.package";
 
   private RuntimeBehavior() {}
 
   public static boolean ignoreCallbackInvocationSkips() {
     return Boolean.getBoolean(IGNORE_CALLBACK_INVOCATION_SKIPS);
   }
 
-  public static List<String> getIdePackageNames() {
+  /**
+   * @return - A comma separated list of packages that represent special listeners which users will
+   *     expect to be executed after executing the regular listeners. Here special listeners can be
+   *     anything that a user feels should be executed ALWAYS at the end.
+   */
+  public static List<String> getPreferentialListeners() {
     String packages =
-        Optional.ofNullable(System.getProperty(IDE_PACKAGE_NAMES)).orElse("com.intellij.rt.*");
+        Optional.ofNullable(System.getProperty(PREFERENTIAL_LISTENERS)).orElse("com.intellij.rt.*");
     return Arrays.asList(packages.split(","));
   }
 

testng-core/src/main/java/org/testng/internal/ListenerOrderDeterminer.java

@@ -11,35 +11,37 @@
 import org.testng.internal.collections.Pair;
 
 /**
- * A Utility that helps us differentiate between a user's listener and an IDE Listener.
+ * A Utility that helps us differentiate between a user's listener and preferential Listener.
  *
  * <p>When dealing with TestNG listeners we would need to ensure that the user created listeners are
- * invoked first followed by IDE listeners. This is required so that we always honour any state
- * changes that a user's listener may have done to the internal state of objects that can affect the
- * outcome of the execution (for e.g.,{@link org.testng.ITestResult})
+ * invoked first followed by Preferential listeners. This is required so that we always honour any
+ * state changes that a user's listener may have done to the internal state of objects that can
+ * affect the outcome of the execution (for e.g.,{@link org.testng.ITestResult})
  *
  * <p>The ordering must be done such that, when dealing with "beforeXXX|afterXXX" we group all the
- * IDE listeners at the end. That way, we can always ensure that the IDE listeners always honour the
- * changes that were done to the TestNG internal states and give a consistent experience for users
- * in the IDE.
+ * IDE listeners at the end. That way, we can always ensure that the preferential listeners (for
+ * e.g., IDE listeners) always honour the changes that were done to the TestNG internal states and
+ * give a consistent experience for users.
  */
 public final class ListenerOrderDeterminer {
 
   private ListenerOrderDeterminer() {
     // Defeat instantiation
   }
 
-  private static final List<String> IDE_PACKAGES =
-      RuntimeBehavior.getIdePackageNames().stream()
+  private static final List<String> PREFERENTIAL_PACKAGES =
+      RuntimeBehavior.getPreferentialListeners().stream()
           .map(each -> each.replaceAll("\\Q.*\\E", ""))
           .collect(Collectors.toList());
 
-  private static final Predicate<Class<?>> IDE_LISTENER =
-      clazz -> IDE_PACKAGES.stream().anyMatch(each -> clazz.getPackage().getName().contains(each));
+  private static final Predicate<Class<?>> SHOULD_ADD_AT_END =
+      clazz ->
+          PREFERENTIAL_PACKAGES.stream()
+              .anyMatch(each -> clazz.getPackage().getName().contains(each));
 
   /**
    * @param original - The original collection of listeners
-   * @return - A re-ordered collection wherein TestNG's known listeners are added at the end
+   * @return - A re-ordered collection wherein preferential listeners are added at the end
    */
   public static <T> List<T> order(Collection<T> original) {
     Pair<List<T>, List<T>> ordered = arrange(original);
@@ -51,34 +53,30 @@ public static <T> List<T> order(Collection<T> original) {
   /**
    * @param original - The original collection of listeners
    * @return - A reversed ordered list wherein the user listeners are found in reverse order
-   *     followed by TestNG known listeners also in reverse order.
+   *     followed by preferential listeners also in reverse order.
    */
   public static <T> List<T> reversedOrder(Collection<T> original) {
     Pair<List<T>, List<T>> ordered = arrange(original);
-    List<T> ideListeners = ordered.first();
+    List<T> preferentialListeners = ordered.first();
     List<T> regularListeners = ordered.second();
     Collections.reverse(regularListeners);
-    Collections.reverse(ideListeners);
-    return Lists.merge(regularListeners, ideListeners);
-  }
-
-  private static boolean isIDEListener(Class<?> clazz) {
-    return IDE_LISTENER.test(clazz);
+    Collections.reverse(preferentialListeners);
+    return Lists.merge(regularListeners, preferentialListeners);
   }
 
   private static <T> Pair<List<T>, List<T>> arrange(Collection<T> original) {
-    List<T> ideListeners = new ArrayList<>();
+    List<T> preferentialListeners = new ArrayList<>();
     List<T> regularListeners = new ArrayList<>();
     original.stream()
         .filter(Objects::nonNull)
         .forEach(
             each -> {
-              if (isIDEListener(each.getClass())) {
-                ideListeners.add(each);
+              if (SHOULD_ADD_AT_END.test(each.getClass())) {
+                preferentialListeners.add(each);
               } else {
                 regularListeners.add(each);
               }
             });
-    return new Pair<>(ideListeners, regularListeners);
+    return new Pair<>(preferentialListeners, regularListeners);
   }
 }