Collections and Utilities

/**
 * Factory methods for List creation and manipulation
 */
public class Lists {
    
    // List creation
    public static <T> List<T> newArrayList();
    public static <T> List<T> newArrayList(T... elements);
    public static <T> List<T> newArrayList(Iterable<? extends T> elements);
    public static <T> List<T> newArrayList(Iterator<? extends T> elements);
    public static <T> List<T> newLinkedList();
    public static <T> List<T> newLinkedList(Iterable<? extends T> elements);
    
    // List operations
    public static <T> List<T> intersection(List<T> list1, List<T> list2);
    public static <T> List<T> merge(Object[] suiteResult, Object[] methodResult);
    public static <T> List<T> createEmpyList();
    public static boolean hasElements(Collection<?> c);
}

/**
 * Factory methods for Map creation and manipulation
 */
public class Maps {
    
    // Map creation
    public static <K, V> Map<K, V> newHashMap();
    public static <K, V> Map<K, V> newHashMap(Map<? extends K, ? extends V> map);
    public static <K, V> Map<K, V> newLinkedHashMap();
    public static <K, V> ConcurrentMap<K, V> newConcurrentMap();
    
    // MultiMap creation
    public static <K, V> ListMultiMap<K, V> newListMultiMap();
    public static <K, V> ListMultiMap<K, V> newListMultiMap(Map<K, Collection<V>> map);
    public static <K, V> SetMultiMap<K, V> newSetMultiMap();
    public static <K, V> SetMultiMap<K, V> newSetMultiMap(Map<K, Collection<V>> map);
    
    // Map operations
    public static boolean hasElements(Map<?, ?> m);
}

/**
 * Factory methods for Set creation
 */
public class Sets {
    
    // Set creation
    public static <T> Set<T> newHashSet();
    public static <T> Set<T> newHashSet(T... elements);
    public static <T> Set<T> newHashSet(Iterable<? extends T> elements);
    public static <T> Set<T> newLinkedHashSet();
    public static <T> Set<T> newLinkedHashSet(Iterable<? extends T> elements);
    
    // Set operations
    public static boolean hasElements(Collection<?> c);
}

import org.testng.collections.Lists;
import org.testng.collections.Maps;
import org.testng.collections.Sets;

public class CollectionUtilityExamples {
    
    public void demonstrateListOperations() {
        // Create lists
        List<String> list1 = Lists.newArrayList("a", "b", "c");
        List<String> list2 = Lists.newArrayList("b", "c", "d");
        List<Integer> numbers = Lists.newLinkedList();
        
        // List operations
        List<String> commonElements = Lists.intersection(list1, list2);
        System.out.println("Common elements: " + commonElements); // [b, c]
        
        // Check if list has elements
        boolean hasElements = Lists.hasElements(list1);
        System.out.println("List has elements: " + hasElements); // true
        
        // Create from iterable
        Set<String> sourceSet = Sets.newHashSet("x", "y", "z");
        List<String> fromSet = Lists.newArrayList(sourceSet);
        System.out.println("From set: " + fromSet);
    }
    
    public void demonstrateMapOperations() {
        // Create maps
        Map<String, Integer> map1 = Maps.newHashMap();
        map1.put("one", 1);
        map1.put("two", 2);
        
        Map<String, Integer> map2 = Maps.newLinkedHashMap(map1);
        Map<String, Integer> concurrentMap = Maps.newConcurrentMap();
        
        // Check if map has elements
        boolean hasElements = Maps.hasElements(map1);
        System.out.println("Map has elements: " + hasElements); // true
        
        // Create MultiMaps
        ListMultiMap<String, String> listMultiMap = Maps.newListMultiMap();
        listMultiMap.put("colors", "red");
        listMultiMap.put("colors", "blue");
        listMultiMap.put("colors", "green");
        
        SetMultiMap<String, String> setMultiMap = Maps.newSetMultiMap();
        setMultiMap.put("categories", "unit");
        setMultiMap.put("categories", "integration");
        setMultiMap.put("categories", "unit"); // Duplicate - will be ignored in set
        
        System.out.println("Colors: " + listMultiMap.get("colors"));
        System.out.println("Categories: " + setMultiMap.get("categories"));
    }
    
    public void demonstrateSetOperations() {
        // Create sets
        Set<String> set1 = Sets.newHashSet("a", "b", "c");
        Set<Integer> set2 = Sets.newLinkedHashSet();
        
        // Create from array
        String[] array = {"x", "y", "z", "x"}; // Duplicate 'x'
        Set<String> uniqueSet = Sets.newHashSet(array);
        System.out.println("Unique elements: " + uniqueSet); // [x, y, z]
        
        // Create from iterable
        List<String> sourceList = Lists.newArrayList("p", "q", "r", "p");
        Set<String> fromList = Sets.newLinkedHashSet(sourceList);
        System.out.println("Unique from list: " + fromList); // [p, q, r] - preserves order
        
        // Check if set has elements
        boolean hasElements = Sets.hasElements(set1);
        System.out.println("Set has elements: " + hasElements); // true
    }
}

/**
 * Interface for maps that can hold multiple values per key
 */
public interface MultiMap<K, V> {
    
    // Basic operations
    void put(K key, V value);
    void putAll(K key, Collection<V> values);
    Collection<V> get(K key);
    Collection<V> remove(K key);
    boolean remove(K key, V value);
    
    // Query operations
    boolean containsKey(K key);
    boolean containsValue(V value);
    boolean containsEntry(K key, V value);
    boolean isEmpty();
    int size();
    
    // Bulk operations
    void clear();
    Set<K> keySet();
    Collection<Collection<V>> values();
    Set<Map.Entry<K, Collection<V>>> entrySet();
    
    // View operations
    Map<K, Collection<V>> asMap();
}

/**
 * MultiMap implementation using Lists for value storage
 */
public class ListMultiMap<K, V> implements MultiMap<K, V> {
    
    public ListMultiMap();
    public ListMultiMap(Map<K, Collection<V>> map);
    
    // Inherited from MultiMap interface
    // Additional List-specific behavior: preserves insertion order and allows duplicates
}

/**
 * MultiMap implementation using Sets for value storage  
 */
public class SetMultiMap<K, V> implements MultiMap<K, V> {
    
    public SetMultiMap();
    public SetMultiMap(Map<K, Collection<V>> map);
    
    // Inherited from MultiMap interface
    // Additional Set-specific behavior: no duplicate values per key
}

public class MultiMapExamples {
    
    public void demonstrateListMultiMap() {
        ListMultiMap<String, String> testGroups = Maps.newListMultiMap();
        
        // Add multiple values for same key (duplicates allowed)
        testGroups.put("smoke", "LoginTest");
        testGroups.put("smoke", "HomePageTest");
        testGroups.put("smoke", "LoginTest"); // Duplicate allowed in ListMultiMap
        
        testGroups.put("regression", "FullWorkflowTest");
        testGroups.put("regression", "DataValidationTest");
        
        // Retrieve values (returns List)
        Collection<String> smokeTests = testGroups.get("smoke");
        System.out.println("Smoke tests: " + smokeTests); // [LoginTest, HomePageTest, LoginTest]
        
        // Check contents
        boolean hasLoginTest = testGroups.containsEntry("smoke", "LoginTest");
        System.out.println("Contains LoginTest in smoke: " + hasLoginTest); // true
        
        // Get all keys
        Set<String> groups = testGroups.keySet();
        System.out.println("Test groups: " + groups); // [smoke, regression]
        
        // Convert to regular map
        Map<String, Collection<String>> asMap = testGroups.asMap();
        System.out.println("As map: " + asMap);
    }
    
    public void demonstrateSetMultiMap() {
        SetMultiMap<String, String> testCategories = Maps.newSetMultiMap();
        
        // Add values (duplicates automatically removed)
        testCategories.put("api", "UserServiceTest");
        testCategories.put("api", "AuthServiceTest");
        testCategories.put("api", "UserServiceTest"); // Duplicate - will be ignored
        
        testCategories.put("ui", "LoginPageTest");
        testCategories.put("ui", "DashboardTest");
        
        // Retrieve values (returns Set)
        Collection<String> apiTests = testCategories.get("api");
        System.out.println("API tests: " + apiTests); // [UserServiceTest, AuthServiceTest]
        
        // Bulk operations
        testCategories.putAll("database", 
            Lists.newArrayList("MigrationTest", "ConnectionTest", "MigrationTest"));
        
        Collection<String> dbTests = testCategories.get("database");
        System.out.println("DB tests: " + dbTests); // [MigrationTest, ConnectionTest] - no duplicates
        
        // Remove specific entry
        boolean removed = testCategories.remove("api", "UserServiceTest");
        System.out.println("Removed UserServiceTest: " + removed); // true
        
        System.out.println("API tests after removal: " + testCategories.get("api"));
    }
}

/**
 * String manipulation utilities
 */
public class Strings {
    
    // String validation
    public static boolean isNullOrEmpty(String string);
    public static boolean isNotNullAndNotEmpty(String string);
    
    // String operations
    public static String join(String separator, Object... objects);
    public static String join(String separator, Iterable<?> objects);
    public static String escapeHtml(String string);
    public static String valueOf(Object object);
    
    // String comparison
    public static boolean equals(String s1, String s2);
    public static int compare(String s1, String s2);
}

import org.testng.util.Strings;

public class StringUtilityExamples {
    
    public void demonstrateStringOperations() {
        // String validation
        String nullString = null;
        String emptyString = "";
        String validString = "TestNG";
        
        System.out.println("Null or empty (null): " + Strings.isNullOrEmpty(nullString)); // true
        System.out.println("Null or empty (empty): " + Strings.isNullOrEmpty(emptyString)); // true
        System.out.println("Null or empty (valid): " + Strings.isNullOrEmpty(validString)); // false
        
        System.out.println("Not null and not empty: " + Strings.isNotNullAndNotEmpty(validString)); // true
        
        // String joining
        String joined1 = Strings.join(", ", "apple", "banana", "cherry");
        System.out.println("Joined with comma: " + joined1); // apple, banana, cherry
        
        List<String> items = Lists.newArrayList("test1", "test2", "test3");
        String joined2 = Strings.join(" | ", items);
        System.out.println("Joined list: " + joined2); // test1 | test2 | test3
        
        // HTML escaping
        String htmlString = "<script>alert('test')</script>";
        String escaped = Strings.escapeHtml(htmlString);
        System.out.println("Escaped HTML: " + escaped); // &lt;script&gt;alert('test')&lt;/script&gt;
        
        // Value conversion
        Object nullObject = null;
        Integer number = 42;
        String nullValue = Strings.valueOf(nullObject);
        String numberValue = Strings.valueOf(number);
        
        System.out.println("Null value: '" + nullValue + "'"); // ''
        System.out.println("Number value: " + numberValue); // 42
        
        // String comparison
        String str1 = "TestNG";
        String str2 = "testng";
        String str3 = "TestNG";
        
        System.out.println("Equals (case sensitive): " + Strings.equals(str1, str3)); // true
        System.out.println("Equals (different case): " + Strings.equals(str1, str2)); // false
        
        int comparison = Strings.compare(str1, str2);
        System.out.println("Comparison result: " + comparison); // negative (str1 < str2 lexicographically)
    }
}

/**
 * General collection utility methods
 */
public class CollectionUtils {
    
    // Collection validation
    public static boolean hasElements(Collection<?> collection);
    public static boolean hasElements(Map<?, ?> map);
    public static boolean hasElements(Object[] array);
    
    // Collection operations  
    public static <T> List<T> filter(Collection<T> collection, Predicate<T> predicate);
    public static <T, R> List<R> transform(Collection<T> collection, Function<T, R> function);
    public static <T> T findFirst(Collection<T> collection, Predicate<T> predicate);
    
    // Array utilities
    public static <T> boolean arrayHasElements(T[] array);
    public static <T> List<T> arrayToList(T[] array);
}

/**
 * Object utility methods
 */
public class Objects {
    
    // Object validation
    public static boolean isNull(Object object);
    public static boolean isNotNull(Object object);
    
    // Object comparison
    public static boolean equals(Object obj1, Object obj2);
    public static int hashCode(Object... objects);
    
    // String representation
    public static String toString(Object object);
    public static String toString(Object object, String defaultValue);
}

public class UtilityExamples {
    
    public void demonstrateCollectionUtils() {
        // Collection validation
        List<String> emptyList = Lists.newArrayList();
        List<String> nonEmptyList = Lists.newArrayList("item1", "item2");
        Map<String, String> emptyMap = Maps.newHashMap();
        String[] emptyArray = new String[0];
        String[] nonEmptyArray = {"a", "b", "c"};
        
        System.out.println("Empty list has elements: " + CollectionUtils.hasElements(emptyList)); // false
        System.out.println("Non-empty list has elements: " + CollectionUtils.hasElements(nonEmptyList)); // true
        System.out.println("Empty map has elements: " + CollectionUtils.hasElements(emptyMap)); // false
        System.out.println("Empty array has elements: " + CollectionUtils.hasElements(emptyArray)); // false
        System.out.println("Non-empty array has elements: " + CollectionUtils.hasElements(nonEmptyArray)); // true
        
        // Array operations
        boolean arrayHasElements = CollectionUtils.arrayHasElements(nonEmptyArray);
        System.out.println("Array has elements: " + arrayHasElements); // true
        
        List<String> listFromArray = CollectionUtils.arrayToList(nonEmptyArray);
        System.out.println("List from array: " + listFromArray); // [a, b, c]
    }
    
    public void demonstrateObjectUtils() {
        // Object validation
        Object nullObject = null;
        Object nonNullObject = "TestNG";
        
        System.out.println("Object is null: " + Objects.isNull(nullObject)); // true
        System.out.println("Object is not null: " + Objects.isNotNull(nonNullObject)); // true
        
        // Object comparison
        String str1 = "test";
        String str2 = "test";
        String str3 = "different";
        
        System.out.println("Objects equal: " + Objects.equals(str1, str2)); // true
        System.out.println("Objects not equal: " + Objects.equals(str1, str3)); // false
        System.out.println("Null comparison: " + Objects.equals(null, null)); // true
        
        // Hash code generation
        int hashCode = Objects.hashCode(str1, str2, 42);
        System.out.println("Combined hash code: " + hashCode);
        
        // String representation
        String nullString = Objects.toString(nullObject);
        String nonNullString = Objects.toString(nonNullObject);
        String defaultString = Objects.toString(nullObject, "DEFAULT");
        
        System.out.println("Null to string: '" + nullString + "'"); // 'null'
        System.out.println("Non-null to string: " + nonNullString); // TestNG
        System.out.println("Null with default: " + defaultString); // DEFAULT
    }
}

/**
 * Utility class for logging test output and generating reports
 */
public class Reporter {
    
    // Logging methods
    public static void log(String message);
    public static void log(String message, boolean logToStandardOut);
    public static void log(String message, int level);
    public static void log(String message, int level, boolean logToStandardOut);
    
    // Output management
    public static List<String> getOutput();
    public static List<String> getOutput(ITestResult result);
    public static void clear();
    
    // Current test result access
    public static ITestResult getCurrentTestResult();
    
    // HTML escaping control
    public static void setEscapeHtml(boolean escapeHtml);
    public static boolean getEscapeHtml();
}

import org.testng.Reporter;
import org.testng.annotations.Test;

public class ReporterExamples {
    
    @Test
    public void demonstrateReporterLogging() {
        // Basic logging
        Reporter.log("Starting test execution");
        Reporter.log("Initializing test data", true); // Also log to standard out
        
        // Logging with levels
        Reporter.log("Debug information", 3);
        Reporter.log("Important message", 1, true);
        
        // Test steps logging
        Reporter.log("Step 1: Opening application");
        performStep1();
        
        Reporter.log("Step 2: User login");
        performStep2();
        
        Reporter.log("Step 3: Verifying dashboard");
        performStep3();
        
        Reporter.log("Test completed successfully");
    }
    
    @Test
    public void demonstrateHtmlLogging() {
        // HTML content in logs
        Reporter.setEscapeHtml(false); // Allow HTML tags
        
        Reporter.log("<h3>Test Results Summary</h3>");
        Reporter.log("<ul>");
        Reporter.log("<li><b>Login:</b> <span style='color:green'>PASSED</span></li>");
        Reporter.log("<li><b>Navigation:</b> <span style='color:green'>PASSED</span></li>");
        Reporter.log("<li><b>Data Entry:</b> <span style='color:red'>FAILED</span></li>");
        Reporter.log("</ul>");
        
        // Include screenshot link
        String screenshotPath = "screenshots/test-failure.png";
        Reporter.log("<a href='" + screenshotPath + "'>View Screenshot</a>");
        
        Reporter.setEscapeHtml(true); // Reset to safe default
    }
    
    @Test
    public void demonstrateReporterUtilities() {
        Reporter.log("Test message 1");
        Reporter.log("Test message 2");
        Reporter.log("Test message 3");
        
        // Get current test result
        ITestResult currentResult = Reporter.getCurrentTestResult();
        if (currentResult != null) {
            String testName = currentResult.getMethod().getMethodName();
            Reporter.log("Current test method: " + testName);
        }
        
        // Get all output for current test
        List<String> output = Reporter.getOutput(currentResult);
        System.out.println("Total log messages: " + output.size());
        
        // Get all output (across all tests)
        List<String> allOutput = Reporter.getOutput();
        System.out.println("Total messages across all tests: " + allOutput.size());
    }
    
    private void performStep1() {
        Reporter.log("  - Application opened successfully");
    }
    
    private void performStep2() {
        Reporter.log("  - User credentials entered");
        Reporter.log("  - Login button clicked");
        Reporter.log("  - Login successful");
    }
    
    private void performStep3() {
        Reporter.log("  - Dashboard loaded");
        Reporter.log("  - User data displayed correctly");
        Reporter.log("  - Navigation menu visible");
    }
}

/**
 * Reflection utility methods
 */
public class ReflectionHelper {
    
    // Method introspection
    public static List<Method> getLocalMethods(Class<?> clazz);
    public static List<Method> excludingMain(List<Method> methods);
    public static List<Method> getDefaultMethods(Class<?> clazz);
    
    // Class introspection
    public static boolean hasDefaultConstructor(Class<?> clazz);
    public static Constructor<?> getDefaultConstructor(Class<?> clazz);
    
    // Method filtering
    public static List<Method> filterMethods(List<Method> methods, Predicate<Method> predicate);
    public static boolean isTestMethod(Method method);
    public static boolean isConfigurationMethod(Method method);
}

// Functional interfaces for collection operations
@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

@FunctionalInterface  
public interface Function<T, R> {
    R apply(T t);
}

// Result map interface for test results
public interface IResultMap {
    void addResult(ITestResult result, ITestNGMethod method);
    Set<ITestResult> getResults(ITestNGMethod method);
    Set<ITestResult> getAllResults();
    void removeResult(ITestNGMethod method);
    Collection<ITestNGMethod> getAllMethods();
    int size();
}

// Common data structures
public class Pair<A, B> {
    public final A first;
    public final B second;
    
    public Pair(A first, B second);
    public A first();
    public B second();
}

public class Triple<A, B, C> {
    public final A first;
    public final B second;
    public final C third;
    
    public Triple(A first, B second, C third);
    public A first();
    public B second();
    public C third();
}