ucn 3.0.0

package/test/fixtures/go/main.go

@@ -0,0 +1,257 @@
+// Package main provides test fixtures for Go parsing.
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+)
+
+// Status represents the status of a task.
+type Status string
+
+const (
+	StatusPending   Status = "pending"
+	StatusActive    Status = "active"
+	StatusCompleted Status = "completed"
+	StatusFailed    Status = "failed"
+)
+
+// Task represents a task entity.
+type Task struct {
+	ID       string
+	Name     string
+	Status   Status
+	Priority int
+	Metadata map[string]interface{}
+}
+
+// TaskManager manages tasks.
+type TaskManager struct {
+	tasks   []*Task
+	mu      sync.RWMutex
+	service *DataService
+}
+
+// NewTaskManager creates a new task manager.
+func NewTaskManager(service *DataService) *TaskManager {
+	return &TaskManager{
+		tasks:   make([]*Task, 0),
+		service: service,
+	}
+}
+
+// AddTask adds a task to the manager.
+func (tm *TaskManager) AddTask(task *Task) error {
+	if err := ValidateTask(task); err != nil {
+		return err
+	}
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+	tm.tasks = append(tm.tasks, task)
+	return nil
+}
+
+// GetTask retrieves a task by ID.
+func (tm *TaskManager) GetTask(id string) (*Task, error) {
+	tm.mu.RLock()
+	defer tm.mu.RUnlock()
+	for _, task := range tm.tasks {
+		if task.ID == id {
+			return task, nil
+		}
+	}
+	return nil, errors.New("task not found")
+}
+
+// GetTasks returns all tasks, optionally filtered.
+func (tm *TaskManager) GetTasks(filter func(*Task) bool) []*Task {
+	tm.mu.RLock()
+	defer tm.mu.RUnlock()
+	if filter == nil {
+		result := make([]*Task, len(tm.tasks))
+		copy(result, tm.tasks)
+		return result
+	}
+	var result []*Task
+	for _, task := range tm.tasks {
+		if filter(task) {
+			result = append(result, task)
+		}
+	}
+	return result
+}
+
+// UpdateTask updates a task by ID.
+func (tm *TaskManager) UpdateTask(id string, updates map[string]interface{}) (*Task, error) {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+	for _, task := range tm.tasks {
+		if task.ID == id {
+			applyUpdates(task, updates)
+			return task, nil
+		}
+	}
+	return nil, errors.New("task not found")
+}
+
+// DeleteTask removes a task by ID.
+func (tm *TaskManager) DeleteTask(id string) bool {
+	tm.mu.Lock()
+	defer tm.mu.Unlock()
+	for i, task := range tm.tasks {
+		if task.ID == id {
+			tm.tasks = append(tm.tasks[:i], tm.tasks[i+1:]...)
+			return true
+		}
+	}
+	return false
+}
+
+// SyncTasks syncs tasks with the service.
+func (tm *TaskManager) SyncTasks(ctx context.Context) error {
+	tm.mu.RLock()
+	defer tm.mu.RUnlock()
+	for _, task := range tm.tasks {
+		if err := tm.service.Save(ctx, task); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ValidateTask validates a task.
+func ValidateTask(task *Task) error {
+	if task == nil {
+		return errors.New("task cannot be nil")
+	}
+	if task.ID == "" {
+		return errors.New("task ID is required")
+	}
+	if task.Name == "" {
+		return errors.New("task name is required")
+	}
+	return nil
+}
+
+// applyUpdates applies updates to a task.
+func applyUpdates(task *Task, updates map[string]interface{}) {
+	if name, ok := updates["name"].(string); ok {
+		task.Name = name
+	}
+	if status, ok := updates["status"].(Status); ok {
+		task.Status = status
+	}
+	if priority, ok := updates["priority"].(int); ok {
+		task.Priority = priority
+	}
+}
+
+// CreateTask is a factory function for tasks.
+func CreateTask(name string, priority int) *Task {
+	return &Task{
+		ID:       generateID(),
+		Name:     name,
+		Status:   StatusPending,
+		Priority: priority,
+		Metadata: make(map[string]interface{}),
+	}
+}
+
+// generateID generates a unique ID.
+func generateID() string {
+	return fmt.Sprintf("task-%d", idCounter)
+}
+
+var idCounter = 0
+
+// FilterByStatus filters tasks by status.
+func FilterByStatus(tasks []*Task, status Status) []*Task {
+	var result []*Task
+	for _, task := range tasks {
+		if task.Status == status {
+			result = append(result, task)
+		}
+	}
+	return result
+}
+
+// FilterByPriority filters tasks by minimum priority.
+func FilterByPriority(tasks []*Task, minPriority int) []*Task {
+	var result []*Task
+	for _, task := range tasks {
+		if task.Priority >= minPriority {
+			result = append(result, task)
+		}
+	}
+	return result
+}
+
+// TaskProcessor processes tasks.
+type TaskProcessor struct {
+	manager *TaskManager
+}
+
+// NewTaskProcessor creates a new task processor.
+func NewTaskProcessor(manager *TaskManager) *TaskProcessor {
+	return &TaskProcessor{manager: manager}
+}
+
+// ProcessAll processes all tasks.
+func (tp *TaskProcessor) ProcessAll() ([]map[string]interface{}, error) {
+	tasks := tp.manager.GetTasks(nil)
+	results := make([]map[string]interface{}, 0, len(tasks))
+	for _, task := range tasks {
+		result, err := tp.processTask(task)
+		if err != nil {
+			return nil, err
+		}
+		results = append(results, result)
+	}
+	return results, nil
+}
+
+// ProcessPending processes only pending tasks.
+func (tp *TaskProcessor) ProcessPending() ([]map[string]interface{}, error) {
+	tasks := tp.manager.GetTasks(func(t *Task) bool {
+		return t.Status == StatusPending
+	})
+	results := make([]map[string]interface{}, 0, len(tasks))
+	for _, task := range tasks {
+		result, err := tp.processTask(task)
+		if err != nil {
+			return nil, err
+		}
+		results = append(results, result)
+	}
+	return results, nil
+}
+
+// processTask processes a single task.
+func (tp *TaskProcessor) processTask(task *Task) (map[string]interface{}, error) {
+	return FormatTask(task), nil
+}
+
+// FormatTask formats a task as a map.
+func FormatTask(task *Task) map[string]interface{} {
+	return map[string]interface{}{
+		"id":       task.ID,
+		"name":     task.Name,
+		"status":   task.Status,
+		"priority": task.Priority,
+	}
+}
+
+// unusedFunction is a function that's never called.
+func unusedFunction() string {
+	return "never used"
+}
+
+func main() {
+	service := NewDataService(nil)
+	manager := NewTaskManager(service)
+	task := CreateTask("Test Task", 1)
+	manager.AddTask(task)
+	fmt.Printf("Created task: %s\n", task.Name)
+}

package/test/fixtures/go/service.go

@@ -0,0 +1,187 @@
+// Package main provides service implementations.
+package main
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+)
+
+// Config holds service configuration.
+type Config struct {
+	APIURL  string
+	Timeout time.Duration
+	Retries int
+	Debug   bool
+}
+
+// DefaultConfig returns the default configuration.
+func DefaultConfig() *Config {
+	return &Config{
+		APIURL:  "https://api.example.com",
+		Timeout: 5 * time.Second,
+		Retries: 3,
+		Debug:   false,
+	}
+}
+
+// DataService provides data operations.
+type DataService struct {
+	config  *Config
+	storage map[string]interface{}
+	mu      sync.RWMutex
+}
+
+// NewDataService creates a new data service.
+func NewDataService(config *Config) *DataService {
+	if config == nil {
+		config = DefaultConfig()
+	}
+	return &DataService{
+		config:  config,
+		storage: make(map[string]interface{}),
+	}
+}
+
+// Save saves an entity.
+func (ds *DataService) Save(ctx context.Context, entity interface{}) error {
+	id, err := getEntityID(entity)
+	if err != nil {
+		return err
+	}
+	ds.mu.Lock()
+	defer ds.mu.Unlock()
+	ds.storage[id] = entity
+	return nil
+}
+
+// Find finds an entity by ID.
+func (ds *DataService) Find(ctx context.Context, id string) (interface{}, error) {
+	ds.mu.RLock()
+	defer ds.mu.RUnlock()
+	if entity, ok := ds.storage[id]; ok {
+		return entity, nil
+	}
+	return nil, errors.New("entity not found")
+}
+
+// FindAll returns all entities.
+func (ds *DataService) FindAll(ctx context.Context) []interface{} {
+	ds.mu.RLock()
+	defer ds.mu.RUnlock()
+	result := make([]interface{}, 0, len(ds.storage))
+	for _, entity := range ds.storage {
+		result = append(result, entity)
+	}
+	return result
+}
+
+// Delete removes an entity.
+func (ds *DataService) Delete(ctx context.Context, id string) error {
+	ds.mu.Lock()
+	defer ds.mu.Unlock()
+	if _, ok := ds.storage[id]; !ok {
+		return errors.New("entity not found")
+	}
+	delete(ds.storage, id)
+	return nil
+}
+
+// Clear removes all entities.
+func (ds *DataService) Clear() {
+	ds.mu.Lock()
+	defer ds.mu.Unlock()
+	ds.storage = make(map[string]interface{})
+}
+
+// getEntityID extracts the ID from an entity.
+func getEntityID(entity interface{}) (string, error) {
+	if task, ok := entity.(*Task); ok {
+		return task.ID, nil
+	}
+	return "", errors.New("unknown entity type")
+}
+
+// CacheService provides caching.
+type CacheService struct {
+	ttl        time.Duration
+	cache      map[string]interface{}
+	timestamps map[string]time.Time
+	mu         sync.RWMutex
+}
+
+// NewCacheService creates a new cache service.
+func NewCacheService(ttl time.Duration) *CacheService {
+	return &CacheService{
+		ttl:        ttl,
+		cache:      make(map[string]interface{}),
+		timestamps: make(map[string]time.Time),
+	}
+}
+
+// Get retrieves a value from cache.
+func (cs *CacheService) Get(key string) (interface{}, bool) {
+	cs.mu.RLock()
+	defer cs.mu.RUnlock()
+	if value, ok := cs.cache[key]; ok {
+		if time.Since(cs.timestamps[key]) < cs.ttl {
+			return value, true
+		}
+	}
+	return nil, false
+}
+
+// Set stores a value in cache.
+func (cs *CacheService) Set(key string, value interface{}) {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+	cs.cache[key] = value
+	cs.timestamps[key] = time.Now()
+}
+
+// Delete removes a value from cache.
+func (cs *CacheService) Delete(key string) bool {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+	if _, ok := cs.cache[key]; ok {
+		delete(cs.cache, key)
+		delete(cs.timestamps, key)
+		return true
+	}
+	return false
+}
+
+// Clear removes all values from cache.
+func (cs *CacheService) Clear() {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+	cs.cache = make(map[string]interface{})
+	cs.timestamps = make(map[string]time.Time)
+}
+
+// CleanupExpired removes expired entries.
+func (cs *CacheService) CleanupExpired() int {
+	cs.mu.Lock()
+	defer cs.mu.Unlock()
+	count := 0
+	for key, ts := range cs.timestamps {
+		if time.Since(ts) >= cs.ttl {
+			delete(cs.cache, key)
+			delete(cs.timestamps, key)
+			count++
+		}
+	}
+	return count
+}
+
+// Repository defines the repository interface.
+type Repository interface {
+	Save(ctx context.Context, entity interface{}) error
+	Find(ctx context.Context, id string) (interface{}, error)
+	FindAll(ctx context.Context) []interface{}
+	Delete(ctx context.Context, id string) error
+}
+
+// Ensure DataService implements Repository.
+var _ Repository = (*DataService)(nil)

package/test/fixtures/java/DataService.java

@@ -0,0 +1,279 @@
+package fixtures;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.time.Instant;
+
+/**
+ * Data service for managing entities.
+ * @param <T> The entity type
+ */
+public class DataService<T> {
+    private final Map<String, T> storage;
+    private final Config config;
+
+    public DataService() {
+        this(new Config());
+    }
+
+    public DataService(Config config) {
+        this.storage = new ConcurrentHashMap<>();
+        this.config = config;
+    }
+
+    /**
+     * Save an entity.
+     */
+    public void save(T entity) {
+        String id = getEntityId(entity);
+        storage.put(id, entity);
+    }
+
+    /**
+     * Find an entity by ID.
+     */
+    public Optional<T> find(String id) {
+        return Optional.ofNullable(storage.get(id));
+    }
+
+    /**
+     * Find all entities.
+     */
+    public List<T> findAll() {
+        return new ArrayList<>(storage.values());
+    }
+
+    /**
+     * Delete an entity by ID.
+     */
+    public boolean delete(String id) {
+        return storage.remove(id) != null;
+    }
+
+    /**
+     * Clear all entities.
+     */
+    public void clear() {
+        storage.clear();
+    }
+
+    /**
+     * Get the config.
+     */
+    public Config getConfig() {
+        return config;
+    }
+
+    /**
+     * Get the entity ID using reflection.
+     */
+    @SuppressWarnings("unchecked")
+    private String getEntityId(T entity) {
+        try {
+            var method = entity.getClass().getMethod("getId");
+            return (String) method.invoke(entity);
+        } catch (Exception e) {
+            throw new RuntimeException("Entity must have getId() method", e);
+        }
+    }
+}
+
+/**
+ * Configuration class.
+ */
+class Config {
+    private String apiUrl;
+    private int timeout;
+    private int retries;
+    private boolean debug;
+
+    public Config() {
+        this.apiUrl = "https://api.example.com";
+        this.timeout = 5000;
+        this.retries = 3;
+        this.debug = false;
+    }
+
+    public String getApiUrl() {
+        return apiUrl;
+    }
+
+    public void setApiUrl(String apiUrl) {
+        this.apiUrl = apiUrl;
+    }
+
+    public int getTimeout() {
+        return timeout;
+    }
+
+    public void setTimeout(int timeout) {
+        this.timeout = timeout;
+    }
+
+    public int getRetries() {
+        return retries;
+    }
+
+    public void setRetries(int retries) {
+        this.retries = retries;
+    }
+
+    public boolean isDebug() {
+        return debug;
+    }
+
+    public void setDebug(boolean debug) {
+        this.debug = debug;
+    }
+}
+
+/**
+ * Repository interface.
+ * @param <T> The entity type
+ */
+interface Repository<T> {
+    void save(T entity);
+    Optional<T> find(String id);
+    List<T> findAll();
+    boolean delete(String id);
+}
+
+/**
+ * Cache service with TTL.
+ * @param <T> The cached value type
+ */
+class CacheService<T> {
+    private final Map<String, CacheEntry<T>> cache;
+    private final long ttlMillis;
+
+    public CacheService(long ttlMillis) {
+        this.cache = new ConcurrentHashMap<>();
+        this.ttlMillis = ttlMillis;
+    }
+
+    /**
+     * Get a value from cache.
+     */
+    public Optional<T> get(String key) {
+        CacheEntry<T> entry = cache.get(key);
+        if (entry != null && !entry.isExpired(ttlMillis)) {
+            return Optional.of(entry.getValue());
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Set a value in cache.
+     */
+    public void set(String key, T value) {
+        cache.put(key, new CacheEntry<>(value));
+    }
+
+    /**
+     * Delete a value from cache.
+     */
+    public boolean delete(String key) {
+        return cache.remove(key) != null;
+    }
+
+    /**
+     * Clear all values from cache.
+     */
+    public void clear() {
+        cache.clear();
+    }
+
+    /**
+     * Remove expired entries.
+     */
+    public int cleanupExpired() {
+        List<String> expired = new ArrayList<>();
+        for (Map.Entry<String, CacheEntry<T>> entry : cache.entrySet()) {
+            if (entry.getValue().isExpired(ttlMillis)) {
+                expired.add(entry.getKey());
+            }
+        }
+        for (String key : expired) {
+            cache.remove(key);
+        }
+        return expired.size();
+    }
+
+    /**
+     * Cache entry with timestamp.
+     */
+    private static class CacheEntry<T> {
+        private final T value;
+        private final Instant timestamp;
+
+        CacheEntry(T value) {
+            this.value = value;
+            this.timestamp = Instant.now();
+        }
+
+        T getValue() {
+            return value;
+        }
+
+        boolean isExpired(long ttlMillis) {
+            return Instant.now().toEpochMilli() - timestamp.toEpochMilli() >= ttlMillis;
+        }
+    }
+}
+
+/**
+ * API client for HTTP requests.
+ */
+class ApiClient {
+    private final Config config;
+
+    public ApiClient(Config config) {
+        this.config = config;
+    }
+
+    /**
+     * Make a GET request.
+     */
+    public Map<String, Object> get(String path) {
+        String url = buildUrl(path);
+        return request("GET", url, null);
+    }
+
+    /**
+     * Make a POST request.
+     */
+    public Map<String, Object> post(String path, Map<String, Object> data) {
+        String url = buildUrl(path);
+        return request("POST", url, data);
+    }
+
+    /**
+     * Make a DELETE request.
+     */
+    public Map<String, Object> delete(String path) {
+        String url = buildUrl(path);
+        return request("DELETE", url, null);
+    }
+
+    /**
+     * Build the full URL.
+     */
+    private String buildUrl(String path) {
+        if (path.startsWith("http")) {
+            return path;
+        }
+        return config.getApiUrl() + path;
+    }
+
+    /**
+     * Make an HTTP request.
+     */
+    private Map<String, Object> request(String method, String url, Map<String, Object> data) {
+        // Simulated request
+        Map<String, Object> result = new HashMap<>();
+        result.put("status", 200);
+        result.put("method", method);
+        result.put("url", url);
+        return result;
+    }
+}