ucn 3.0.0

package/test/fixtures/java/Main.java

@@ -0,0 +1,287 @@
+package fixtures;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+/**
+ * Main Java test fixtures.
+ * Tests classes, interfaces, generics, and annotations.
+ */
+public class Main {
+
+    /**
+     * Status enum representing task states.
+     */
+    public enum Status {
+        PENDING("pending"),
+        ACTIVE("active"),
+        COMPLETED("completed"),
+        FAILED("failed");
+
+        private final String value;
+
+        Status(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
+
+    /**
+     * Task class representing a task entity.
+     */
+    public static class Task {
+        private String id;
+        private String name;
+        private Status status;
+        private int priority;
+        private Map<String, Object> metadata;
+
+        public Task(String id, String name) {
+            this.id = id;
+            this.name = name;
+            this.status = Status.PENDING;
+            this.priority = 1;
+            this.metadata = new HashMap<>();
+        }
+
+        public String getId() {
+            return id;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+        public Status getStatus() {
+            return status;
+        }
+
+        public void setStatus(Status status) {
+            this.status = status;
+        }
+
+        public int getPriority() {
+            return priority;
+        }
+
+        public void setPriority(int priority) {
+            this.priority = priority;
+        }
+
+        public Map<String, Object> getMetadata() {
+            return metadata;
+        }
+
+        public boolean isComplete() {
+            return status == Status.COMPLETED;
+        }
+    }
+
+    /**
+     * Generic task manager class.
+     * @param <T> The task type
+     */
+    public static class TaskManager<T extends Task> {
+        private final List<T> tasks;
+        private final DataService<T> service;
+
+        public TaskManager(DataService<T> service) {
+            this.tasks = new ArrayList<>();
+            this.service = service;
+        }
+
+        public void addTask(T task) throws ValidationException {
+            validateTask(task);
+            tasks.add(task);
+        }
+
+        public Optional<T> getTask(String id) {
+            return tasks.stream()
+                    .filter(t -> t.getId().equals(id))
+                    .findFirst();
+        }
+
+        public List<T> getTasks(Predicate<T> filter) {
+            if (filter == null) {
+                return new ArrayList<>(tasks);
+            }
+            return tasks.stream()
+                    .filter(filter)
+                    .collect(Collectors.toList());
+        }
+
+        public Optional<T> updateTask(String id, String name, Status status) {
+            return getTask(id).map(task -> {
+                if (name != null) {
+                    task.setName(name);
+                }
+                if (status != null) {
+                    task.setStatus(status);
+                }
+                return task;
+            });
+        }
+
+        public boolean deleteTask(String id) {
+            return tasks.removeIf(t -> t.getId().equals(id));
+        }
+
+        public CompletableFuture<Integer> syncTasks() {
+            return CompletableFuture.supplyAsync(() -> {
+                int count = 0;
+                for (T task : tasks) {
+                    service.save(task);
+                    count++;
+                }
+                return count;
+            });
+        }
+
+        public int count() {
+            return tasks.size();
+        }
+    }
+
+    /**
+     * Validate a task.
+     */
+    public static void validateTask(Task task) throws ValidationException {
+        if (task == null) {
+            throw new ValidationException("Task cannot be null");
+        }
+        if (task.getId() == null || task.getId().isEmpty()) {
+            throw new ValidationException("Task ID is required");
+        }
+        if (task.getName() == null || task.getName().isEmpty()) {
+            throw new ValidationException("Task name is required");
+        }
+    }
+
+    /**
+     * Custom exception for validation errors.
+     */
+    public static class ValidationException extends Exception {
+        public ValidationException(String message) {
+            super(message);
+        }
+    }
+
+    /**
+     * Factory method to create a task.
+     */
+    public static Task createTask(String name, int priority) {
+        String id = generateId();
+        Task task = new Task(id, name);
+        task.setPriority(priority);
+        return task;
+    }
+
+    private static int idCounter = 0;
+
+    /**
+     * Generate a unique ID.
+     */
+    private static synchronized String generateId() {
+        return "task-" + (idCounter++);
+    }
+
+    /**
+     * Filter tasks by status.
+     */
+    public static List<Task> filterByStatus(List<Task> tasks, Status status) {
+        return tasks.stream()
+                .filter(t -> t.getStatus() == status)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Filter tasks by minimum priority.
+     */
+    public static List<Task> filterByPriority(List<Task> tasks, int minPriority) {
+        return tasks.stream()
+                .filter(t -> t.getPriority() >= minPriority)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Task processor class.
+     */
+    public static class TaskProcessor {
+        private final TaskManager<Task> manager;
+
+        public TaskProcessor(TaskManager<Task> manager) {
+            this.manager = manager;
+        }
+
+        public List<Map<String, Object>> processAll() {
+            return manager.getTasks(null).stream()
+                    .map(this::processTask)
+                    .collect(Collectors.toList());
+        }
+
+        public List<Map<String, Object>> processPending() {
+            return manager.getTasks(t -> t.getStatus() == Status.PENDING).stream()
+                    .map(this::processTask)
+                    .collect(Collectors.toList());
+        }
+
+        private Map<String, Object> processTask(Task task) {
+            return formatTask(task);
+        }
+    }
+
+    /**
+     * Format a task as a map.
+     */
+    public static Map<String, Object> formatTask(Task task) {
+        Map<String, Object> map = new HashMap<>();
+        map.put("id", task.getId());
+        map.put("name", task.getName());
+        map.put("status", task.getStatus().getValue());
+        map.put("priority", task.getPriority());
+        return map;
+    }
+
+    /**
+     * Higher-order function example.
+     */
+    public static <T, R> Function<T, R> withLogging(Function<T, R> fn, String name) {
+        return input -> {
+            System.out.println("Calling " + name);
+            R result = fn.apply(input);
+            System.out.println("Finished " + name);
+            return result;
+        };
+    }
+
+    /**
+     * Unused method for deadcode detection.
+     */
+    @SuppressWarnings("unused")
+    private static String unusedMethod() {
+        return "never used";
+    }
+
+    public static void main(String[] args) {
+        DataService<Task> service = new DataService<>();
+        TaskManager<Task> manager = new TaskManager<>(service);
+
+        try {
+            Task task = createTask("Test Task", 1);
+            manager.addTask(task);
+            System.out.println("Created " + manager.count() + " tasks");
+        } catch (ValidationException e) {
+            System.err.println("Validation error: " + e.getMessage());
+        }
+    }
+}

package/test/fixtures/java/Utils.java

@@ -0,0 +1,199 @@
+package fixtures;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * Utility functions for data manipulation.
+ */
+public class Utils {
+
+    /**
+     * Format data as a map.
+     */
+    public static Map<String, Object> formatData(Object data) {
+        if (data == null) {
+            return new HashMap<>();
+        }
+        if (data instanceof Map) {
+            return new HashMap<>((Map<String, Object>) data);
+        }
+        Map<String, Object> result = new HashMap<>();
+        result.put("value", data);
+        return result;
+    }
+
+    /**
+     * Validate that a value is not null.
+     */
+    public static <T> T validateNotNull(T value, String message) {
+        if (value == null) {
+            throw new IllegalArgumentException(message);
+        }
+        return value;
+    }
+
+    /**
+     * Deep merge two maps.
+     */
+    public static Map<String, Object> deepMerge(
+            Map<String, Object> base,
+            Map<String, Object> updates) {
+        Map<String, Object> result = new HashMap<>(base);
+        for (Map.Entry<String, Object> entry : updates.entrySet()) {
+            String key = entry.getKey();
+            Object value = entry.getValue();
+            if (result.containsKey(key) &&
+                result.get(key) instanceof Map &&
+                value instanceof Map) {
+                result.put(key, deepMerge(
+                    (Map<String, Object>) result.get(key),
+                    (Map<String, Object>) value
+                ));
+            } else {
+                result.put(key, value);
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Flatten a nested list.
+     */
+    public static <T> List<T> flatten(List<List<T>> nested) {
+        return nested.stream()
+                .flatMap(List::stream)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Split a list into chunks.
+     */
+    public static <T> List<List<T>> chunk(List<T> items, int size) {
+        List<List<T>> chunks = new ArrayList<>();
+        for (int i = 0; i < items.size(); i += size) {
+            chunks.add(items.subList(i, Math.min(i + size, items.size())));
+        }
+        return chunks;
+    }
+
+    /**
+     * Safely get a nested value from a map.
+     */
+    public static Object safeGet(Map<String, Object> map, String path) {
+        String[] keys = path.split("\\.");
+        Object current = map;
+        for (String key : keys) {
+            if (current instanceof Map) {
+                current = ((Map<String, Object>) current).get(key);
+            } else {
+                return null;
+            }
+        }
+        return current;
+    }
+
+    /**
+     * Transform all keys in a map.
+     */
+    public static Map<String, Object> transformKeys(
+            Map<String, Object> map,
+            Function<String, String> transformer) {
+        Map<String, Object> result = new HashMap<>();
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            result.put(transformer.apply(entry.getKey()), entry.getValue());
+        }
+        return result;
+    }
+
+    /**
+     * Convert snake_case to camelCase.
+     */
+    public static String snakeToCamel(String name) {
+        StringBuilder result = new StringBuilder();
+        boolean capitalizeNext = false;
+        for (char c : name.toCharArray()) {
+            if (c == '_') {
+                capitalizeNext = true;
+            } else if (capitalizeNext) {
+                result.append(Character.toUpperCase(c));
+                capitalizeNext = false;
+            } else {
+                result.append(c);
+            }
+        }
+        return result.toString();
+    }
+
+    /**
+     * Convert camelCase to snake_case.
+     */
+    public static String camelToSnake(String name) {
+        StringBuilder result = new StringBuilder();
+        for (char c : name.toCharArray()) {
+            if (Character.isUpperCase(c)) {
+                if (result.length() > 0) {
+                    result.append('_');
+                }
+                result.append(Character.toLowerCase(c));
+            } else {
+                result.append(c);
+            }
+        }
+        return result.toString();
+    }
+
+    /**
+     * Data transformer class.
+     */
+    public static class DataTransformer {
+        private final List<Function<Object, Object>> transformations;
+
+        public DataTransformer() {
+            this.transformations = new ArrayList<>();
+        }
+
+        /**
+         * Add a transformation.
+         */
+        public DataTransformer addTransformation(Function<Object, Object> fn) {
+            transformations.add(fn);
+            return this;
+        }
+
+        /**
+         * Apply all transformations.
+         */
+        public Object transform(Object data) {
+            Object result = data;
+            for (Function<Object, Object> fn : transformations) {
+                result = fn.apply(result);
+            }
+            return result;
+        }
+
+        /**
+         * Clear all transformations.
+         */
+        public void clear() {
+            transformations.clear();
+        }
+    }
+
+    /**
+     * Process and format data.
+     */
+    public static Map<String, Object> processAndFormat(Object data) {
+        Object validated = validateNotNull(data, "Data cannot be null");
+        return formatData(validated);
+    }
+
+    /**
+     * Unused method for deadcode detection.
+     */
+    @SuppressWarnings("unused")
+    private static void unusedHelper() {
+        // This method is never called
+    }
+}

package/test/fixtures/java/pom.xml

@@ -0,0 +1,6 @@
+<project>
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>fixtures</groupId>
+  <artifactId>java-fixtures</artifactId>
+  <version>1.0.0</version>
+</project>

package/test/fixtures/javascript/main.js

@@ -0,0 +1,109 @@
+/**
+ * Main entry point for the JavaScript test fixtures.
+ * Tests various JavaScript constructs.
+ */
+
+const { helper, utilFunc } = require('./utils');
+const Service = require('./service');
+
+// Constants
+const CONFIG = {
+  timeout: 5000,
+  retries: 3
+};
+
+/**
+ * Process data using the helper function.
+ * @param {Object} data - Input data
+ * @returns {Object} Processed data
+ */
+function processData(data) {
+  const validated = validateInput(data);
+  const result = helper(validated);
+  return transformOutput(result);
+}
+
+// Arrow function
+const validateInput = (input) => {
+  if (!input) {
+    throw new Error('Input is required');
+  }
+  return { ...input, validated: true };
+};
+
+/**
+ * Transform the output data.
+ */
+function transformOutput(data) {
+  return {
+    ...data,
+    transformed: true,
+    timestamp: Date.now()
+  };
+}
+
+// Async function
+async function fetchAndProcess(url) {
+  const service = new Service();
+  const response = await service.fetch(url);
+  return processData(response);
+}
+
+// Higher-order function
+function createProcessor(transformer) {
+  return function(data) {
+    const processed = processData(data);
+    return transformer(processed);
+  };
+}
+
+// Function with callback
+function processWithCallback(data, callback) {
+  try {
+    const result = processData(data);
+    callback(null, result);
+  } catch (err) {
+    callback(err, null);
+  }
+}
+
+// Generator function
+function* dataGenerator(items) {
+  for (const item of items) {
+    yield processData(item);
+  }
+}
+
+// Class usage
+class DataProcessor {
+  constructor(config = CONFIG) {
+    this.config = config;
+    this.service = new Service();
+  }
+
+  async process(data) {
+    return fetchAndProcess(data);
+  }
+
+  static create(config) {
+    return new DataProcessor(config);
+  }
+}
+
+// Immediately invoked
+const initialized = (function() {
+  return { ready: true };
+})();
+
+// Default export simulation
+module.exports = {
+  processData,
+  validateInput,
+  transformOutput,
+  fetchAndProcess,
+  createProcessor,
+  processWithCallback,
+  dataGenerator,
+  DataProcessor,
+  CONFIG
+};

package/test/fixtures/javascript/package.json

@@ -0,0 +1 @@
+{"name": "javascript-fixtures", "version": "1.0.0"}

package/test/fixtures/javascript/service.js

@@ -0,0 +1,88 @@
+/**
+ * Service class for external operations.
+ */
+
+const { deepClone, mergeObjects } = require('./utils');
+
+class Service {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || 'https://api.example.com';
+    this.timeout = options.timeout || 5000;
+    this.headers = mergeObjects({ 'Content-Type': 'application/json' }, options.headers || {});
+  }
+
+  /**
+   * Fetch data from a URL.
+   * @param {string} url - The URL to fetch
+   * @returns {Promise<Object>} The response data
+   */
+  async fetch(url) {
+    const fullUrl = this.buildUrl(url);
+    const response = await this.makeRequest(fullUrl);
+    return this.parseResponse(response);
+  }
+
+  /**
+   * Build the full URL.
+   */
+  buildUrl(path) {
+    if (path.startsWith('http')) {
+      return path;
+    }
+    return `${this.baseUrl}${path}`;
+  }
+
+  /**
+   * Make the HTTP request.
+   */
+  async makeRequest(url) {
+    // Simulated request
+    return {
+      status: 200,
+      data: { url, timestamp: Date.now() }
+    };
+  }
+
+  /**
+   * Parse the response data.
+   */
+  parseResponse(response) {
+    if (response.status !== 200) {
+      throw new Error(`Request failed: ${response.status}`);
+    }
+    return deepClone(response.data);
+  }
+
+  /**
+   * Post data to a URL.
+   */
+  async post(url, data) {
+    const fullUrl = this.buildUrl(url);
+    const response = await this.makeRequest(fullUrl, 'POST', data);
+    return this.parseResponse(response);
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+/**
+ * Get the singleton service instance.
+ */
+function getService(options) {
+  if (!instance) {
+    instance = new Service(options);
+  }
+  return instance;
+}
+
+/**
+ * Reset the singleton (for testing).
+ */
+function resetService() {
+  instance = null;
+}
+
+module.exports = Service;
+module.exports.getService = getService;
+module.exports.resetService = resetService;