pi-usereq 0.4.0

package/tests/fixtures/fixture_go.go

@@ -0,0 +1,341 @@
+// @file fixture_go.go
+// @brief Go language test fixture.
+// @details Parser validation constructs.
+
+// Single line comment
+/* Multi-line
+   comment */
+
+// Package main is the entry point for the application.
+// It demonstrates Go-specific constructs including generics,
+// goroutines, channels, embedded structs, and type switches.
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"sync"
+)
+
+/* ── Constants and variables ──────────────────────────────────────────── */
+
+// MaxSize defines the upper bound for buffer allocation.
+const MaxSize = 100
+
+// globalVar is a package-level mutable counter.
+var globalVar = 0
+
+// Iota-based enum-like constants for log levels.
+const (
+	// LogDebug is the most verbose logging level.
+	LogDebug = iota
+	// LogInfo is the standard informational level.
+	LogInfo
+	// LogError logs only error conditions.
+	LogError
+)
+
+/* ── Struct definitions ───────────────────────────────────────────────── */
+
+// Server represents an HTTP server with host and port configuration.
+// It embeds sync.Mutex for concurrent access protection.
+type Server struct {
+	Port int    // Port number the server listens on.
+	Host string // Hostname or IP address to bind to.
+	sync.Mutex  // Embedded mutex for thread-safe operations.
+	handlers map[string]HandlerFunc // Route handler registry.
+}
+
+// HandlerFunc defines the signature for HTTP request handlers.
+type HandlerFunc func(ctx context.Context, req []byte) ([]byte, error)
+
+// Embedded struct demonstrating composition over inheritance.
+type Address struct {
+	Street string // Street name and number.
+	City   string // City name.
+	Zip    string // Postal/ZIP code.
+}
+
+// Employee composes Person-like fields with an embedded Address.
+type Employee struct {
+	Name    string  // Full name of the employee.
+	Age     int     // Age in years.
+	Address         // Embedded address (promoted fields).
+	Manager *Employee // Optional reference to reporting manager.
+}
+
+/* ── Interface definitions ────────────────────────────────────────────── */
+
+// Handler defines the interface for request processing components.
+type Handler interface {
+	// Handle processes a request and returns a response.
+	Handle(ctx context.Context, data []byte) error
+}
+
+// ReadWriteCloser composes standard io interfaces.
+type ReadWriteCloser interface {
+	io.Reader
+	io.Writer
+	io.Closer
+}
+
+/* ── Type aliases and definitions ─────────────────────────────────────── */
+
+// MyInt is a custom integer type supporting additional methods.
+type MyInt int
+
+// String returns the string representation of MyInt.
+func (m MyInt) String() string {
+	return fmt.Sprintf("MyInt(%d)", int(m))
+}
+
+/* ── Generic types (Go 1.18+) ─────────────────────────────────────────── */
+
+// Pair holds two values of potentially different types.
+// @tparam A The type of the first element.
+// @tparam B The type of the second element.
+type Pair[A any, B any] struct {
+	First  A // First element of the pair.
+	Second B // Second element of the pair.
+}
+
+// Ordered constrains types that support comparison operators.
+type Ordered interface {
+	~int | ~float64 | ~string
+}
+
+/* ── Functions ────────────────────────────────────────────────────────── */
+
+// main is the application entry point.
+func main() {
+	fmt.Println("hello")
+}
+
+// init runs before main for package-level initialization.
+func init() {
+	// Package initialization — set default global state
+	globalVar = 1
+}
+
+// Start begins listening on the configured host and port.
+// @receiver s Pointer to Server instance.
+func (s *Server) Start() error {
+	s.Lock()
+	defer s.Unlock()
+	// Validate port before binding
+	if s.Port <= 0 {
+		return fmt.Errorf("invalid port: %d", s.Port)
+	}
+	fmt.Printf("Starting on %s:%d\n", s.Host, s.Port)
+	return nil
+}
+
+// Register adds a handler function for a specific route path.
+// @receiver s Pointer to Server.
+// @param path The URL path to register.
+// @param handler The function to invoke for this path.
+func (s *Server) Register(path string, handler HandlerFunc) {
+	if s.handlers == nil {
+		s.handlers = make(map[string]HandlerFunc)
+	}
+	s.handlers[path] = handler
+}
+
+/* ── Generic function ─────────────────────────────────────────────────── */
+
+// Max returns the larger of two ordered values.
+// @tparam T Type constrained to Ordered interface.
+// @param a First value.
+// @param b Second value.
+// @return The greater of a and b.
+func Max[T Ordered](a, b T) T {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// Filter returns elements matching a predicate.
+// @tparam T Element type (any).
+// @param items Slice of items to filter.
+// @param pred Predicate function returning true to keep element.
+// @return Filtered slice.
+func Filter[T any](items []T, pred func(T) bool) []T {
+	result := make([]T, 0)
+	for _, item := range items {
+		if pred(item) {
+			result = append(result, item)
+		}
+	}
+	return result
+}
+
+/* ── Multiple return values ───────────────────────────────────────────── */
+
+// Divide performs safe integer division with error handling.
+// @param a Dividend.
+// @param b Divisor; must not be zero.
+// @return Quotient and remainder, or error if b is zero.
+func Divide(a, b int) (int, int, error) {
+	if b == 0 {
+		return 0, 0, fmt.Errorf("division by zero")
+	}
+	return a / b, a % b, nil
+}
+
+/* ── Named return values ──────────────────────────────────────────────── */
+
+// ParseConfig extracts host and port from a config string.
+// @param input Configuration string in "host:port" format.
+// @return Named host and port values, or error.
+func ParseConfig(input string) (host string, port int, err error) {
+	// Named returns allow bare return in simple cases
+	_, scanErr := fmt.Sscanf(input, "%s:%d", &host, &port)
+	if scanErr != nil {
+		err = scanErr
+		return
+	}
+	return
+}
+
+/* ── Closure ──────────────────────────────────────────────────────────── */
+
+// Counter returns a closure that increments and returns a count.
+// @return Closure yielding successive integer counts.
+func Counter() func() int {
+	count := 0
+	return func() int {
+		// Capture count from enclosing scope
+		count++
+		return count
+	}
+}
+
+/* ── Goroutine and channels ───────────────────────────────────────────── */
+
+// FanOut distributes work across n goroutines via channels.
+// @param items Slice of strings to process.
+// @param workers Number of concurrent worker goroutines.
+// @return Channel delivering processed results.
+func FanOut(items []string, workers int) <-chan string {
+	results := make(chan string, len(items))
+	var wg sync.WaitGroup
+
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go func(id int) {
+			defer wg.Done()
+			// Each worker processes items from the slice
+			for _, item := range items {
+				results <- fmt.Sprintf("[%d] %s", id, item)
+			}
+		}(i)
+	}
+
+	// Close channel when all workers finish
+	go func() {
+		wg.Wait()
+		close(results)
+	}()
+
+	return results
+}
+
+/* ── Type switch ──────────────────────────────────────────────────────── */
+
+// Describe returns a description string for any value using type switch.
+// @param v Any value to describe.
+// @return Human-readable type description.
+func Describe(v interface{}) string {
+	switch val := v.(type) {
+	case int:
+		return fmt.Sprintf("int: %d", val)
+	case string:
+		return fmt.Sprintf("string: %q", val)
+	case bool:
+		if val {
+			return "bool: true"
+		}
+		return "bool: false"
+	case nil:
+		return "nil"
+	default:
+		return fmt.Sprintf("unknown: %T", val)
+	}
+}
+
+/* ── Defer and panic recovery ─────────────────────────────────────────── */
+
+// SafeExecute runs a function with panic recovery.
+// @param fn The function to execute safely.
+// @return Error if fn panicked, nil otherwise.
+func SafeExecute(fn func()) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			// Convert panic to error
+			err = fmt.Errorf("panic: %v", r)
+		}
+	}()
+	fn()
+	return nil
+}
+
+/* coverage extension block */
+package utilx
+package configx
+package jobsx
+package metricx
+import "os"
+import "time"
+import "strings"
+import "bytes"
+func (s *Server) Stop() {}
+func (s *Server) Reset() {}
+type Session struct { Id string }
+type Bucket struct { Name string }
+type Closer interface { Close() error }
+type Starter interface { Start() error }
+type UserAlias string
+type Amount int
+type Resolver func(string) error
+const RetryCount = 3
+var LastError error
+
+// REQ-COVER-SRS-231 START
+// @REQ-COVER-SRS-231 block 1
+// @brief Coverage helper construct 1.
+// @details Provides deterministic fixture-level Doxygen coverage block 1.
+// @param value Input value for helper construct 1.
+// @return Output value for helper construct 1.
+func reqCoverGo1(value int) int { return value + 1 }
+
+// @REQ-COVER-SRS-231 block 2
+// @brief Coverage helper construct 2.
+// @details Provides deterministic fixture-level Doxygen coverage block 2.
+// @param value Input value for helper construct 2.
+// @return Output value for helper construct 2.
+func reqCoverGo2(value int) int { return value + 2 }
+
+// @REQ-COVER-SRS-231 block 3
+// @brief Coverage helper construct 3.
+// @details Provides deterministic fixture-level Doxygen coverage block 3.
+// @param value Input value for helper construct 3.
+// @return Output value for helper construct 3.
+func reqCoverGo3(value int) int { return value + 3 }
+
+// @REQ-COVER-SRS-231 block 4
+// @brief Coverage helper construct 4.
+// @details Provides deterministic fixture-level Doxygen coverage block 4.
+// @param value Input value for helper construct 4.
+// @return Output value for helper construct 4.
+func reqCoverGo4(value int) int { return value + 4 }
+
+// @REQ-COVER-SRS-231 block 5
+// @brief Coverage helper construct 5.
+// @details Provides deterministic fixture-level Doxygen coverage block 5.
+// @param value Input value for helper construct 5.
+// @return Output value for helper construct 5.
+func reqCoverGo5(value int) int { return value + 5 }
+
+// REQ-COVER-SRS-231 END

package/tests/fixtures/fixture_haskell.hs

@@ -0,0 +1,250 @@
+-- @file fixture_haskell.hs
+-- @brief Comprehensive Haskell test fixture for parser validation.
+-- @details Covers typeclasses with instances, GADTs, type families,
+--          monadic computations, applicatives, pattern guards,
+--          where clauses, let bindings, and deriving strategies.
+-- Single line comment
+{- Multi-line
+   comment -}
+
+-- | Module declaration with explicit export list.
+module MyModule
+  ( Name
+  , Person(..)
+  , Printable(..)
+  , Expr(..)
+  , greet
+  , safeDiv
+  , processList
+  , fibonacci
+  ) where
+
+import Data.List (sort, nub, intercalate)
+import Data.Maybe (fromMaybe, isJust)
+import qualified Data.Map as Map
+import Control.Monad (when, unless, forM_)
+
+-- ── Type aliases ───────────────────────────────────────────────────────
+
+-- | Simple alias for human-readable name strings.
+type Name = String
+
+-- | Mapping from string keys to integer values.
+type Config = Map.Map String Int
+
+-- | Function type alias for transformations.
+type Transform a = a -> a
+
+-- ── Data types ─────────────────────────────────────────────────────────
+
+-- | Record type representing a person with name and age fields.
+-- Used as the primary entity throughout this module.
+data Person = Person
+  { personName :: String   -- ^ Full name of the person.
+  , personAge  :: Int      -- ^ Age in years (non-negative).
+  } deriving (Show, Eq, Ord)
+
+-- | Binary tree data structure with parameterized element type.
+-- Supports insertion, lookup, and fold operations.
+data Tree a
+  = Leaf                      -- ^ Empty tree (base case).
+  | Node a (Tree a) (Tree a)  -- ^ Node with value and subtrees.
+  deriving (Show, Eq)
+
+-- | Expression AST for a simple calculator language.
+-- Demonstrates GADT-like pattern (standard ADT form).
+data Expr
+  = Lit Double           -- ^ Numeric literal.
+  | Add Expr Expr        -- ^ Addition of two expressions.
+  | Mul Expr Expr        -- ^ Multiplication of two expressions.
+  | Neg Expr             -- ^ Negation of an expression.
+  deriving (Show)
+
+-- | Result type for operations that may fail.
+data Result a
+  = Ok a          -- ^ Successful result carrying a value.
+  | Err String    -- ^ Error result with message.
+  deriving (Show)
+
+-- ── Typeclasses ────────────────────────────────────────────────────────
+
+-- | Typeclass for types that can be printed as formatted strings.
+class Printable a where
+  -- | Convert a value to its formatted string representation.
+  printIt :: a -> String
+
+  -- | Convert a value to a debug string (default implementation).
+  debugPrint :: a -> String
+  debugPrint x = "Debug: " ++ printIt x
+
+-- | Typeclass for types that can be serialized to key-value pairs.
+class Serializable a where
+  -- | Serialize a value to a list of key-value string pairs.
+  serialize :: a -> [(String, String)]
+
+-- ── Typeclass instances ────────────────────────────────────────────────
+
+-- | Printable instance for Person; formats as "Name (Age)".
+instance Printable Person where
+  printIt p = personName p ++ " (" ++ show (personAge p) ++ ")"
+
+-- | Serializable instance for Person.
+instance Serializable Person where
+  serialize p =
+    [ ("name", personName p)
+    , ("age", show (personAge p))
+    ]
+
+-- | Functor instance for Tree enabling fmap over tree nodes.
+instance Functor Tree where
+  fmap _ Leaf         = Leaf
+  fmap f (Node x l r) = Node (f x) (fmap f l) (fmap f r)
+
+-- | Functor instance for Result.
+instance Functor Result where
+  fmap f (Ok a)  = Ok (f a)
+  fmap _ (Err e) = Err e
+
+-- ── Functions ──────────────────────────────────────────────────────────
+
+-- @brief Produce a greeting string for a given name. @details Uses string concatenation with the (++) operator. @param name Input name value. @return Greeting message.
+-- Deterministic helper for basic string assembly.
+greet :: String -> String
+greet name = "Hello " ++ name
+
+-- @brief Safe division returning Nothing on division by zero. @details Demonstrates pattern guards for conditional logic. @param x Numerator value. @return Maybe quotient.
+-- Returns Nothing when the denominator equals zero.
+safeDiv :: Double -> Double -> Maybe Double
+safeDiv _ 0 = Nothing
+safeDiv x y = Just (x / y)
+
+-- @brief Evaluate an expression AST to its numeric result. @details Recursively traverses the expression tree. @param expr Expression to evaluate. @return Numeric result.
+-- Handles literals, sums, products, and negations.
+eval :: Expr -> Double
+eval (Lit n)   = n
+eval (Add a b) = eval a + eval b
+eval (Mul a b) = eval a * eval b
+eval (Neg e)   = -(eval e)
+
+-- @brief Process a list of integers with multiple filter stages. @details Removes duplicates, sorts, and filters positive values. @param xs Input integer list. @return Processed integer list.
+-- Preserves deterministic ordering and positivity constraint.
+processList :: [Int] -> [Int]
+processList xs = result
+  where
+    -- Remove duplicates first
+    unique = nub xs
+    -- Sort in ascending order
+    sorted = sort unique
+    -- Keep only positive values
+    result = filter (> 0) sorted
+
+-- @brief Compute the nth Fibonacci number using pattern matching. @details Uses accumulator recursion for efficiency. @param n Sequence index. @return Fibonacci value at index n.
+-- Rejects negative input through an explicit error branch.
+fibonacci :: Int -> Integer
+fibonacci n
+  | n < 0     = error "negative input"
+  | n == 0    = 0
+  | n == 1    = 1
+  | otherwise = go n 0 1
+  where
+    go 0 a _ = a
+    go k a b = go (k - 1) b (a + b)
+
+-- | Insert a value into a binary search tree.
+-- Maintains BST ordering invariant.
+insertTree :: (Ord a) => a -> Tree a -> Tree a
+insertTree x Leaf = Node x Leaf Leaf
+insertTree x (Node y left right)
+  | x < y     = Node y (insertTree x left) right
+  | x > y     = Node y left (insertTree x right)
+  | otherwise  = Node y left right
+
+-- | Fold a tree to a single value using a combining function.
+-- Performs an in-order traversal.
+foldTree :: (b -> a -> b) -> b -> Tree a -> b
+foldTree _ acc Leaf           = acc
+foldTree f acc (Node x l r) =
+  let leftAcc = foldTree f acc l
+      midAcc  = f leftAcc x
+  in foldTree f midAcc r
+
+-- | Lookup a value in a config map with a default fallback.
+-- Demonstrates Maybe handling with fromMaybe.
+lookupConfig :: Config -> String -> Int -> Int
+lookupConfig cfg key def = fromMaybe def (Map.lookup key cfg)
+
+-- | Apply a transformation function n times to an initial value.
+-- Higher-order function with explicit recursion.
+applyN :: Int -> Transform a -> a -> a
+applyN 0 _ x = x
+applyN n f x = applyN (n - 1) f (f x)
+
+-- | Format a list of persons as a comma-separated string.
+-- Combines typeclass method with list processing.
+formatPersons :: (Printable a) => [a] -> String
+formatPersons ps = intercalate ", " (map printIt ps)
+
+-- | Monadic computation chaining multiple Maybe operations.
+-- Returns Nothing if any step fails.
+safeCompute :: Double -> Double -> Double -> Maybe Double
+safeCompute x y z = do
+  -- Each step may fail (division by zero)
+  a <- safeDiv x y
+  b <- safeDiv a z
+  return (a + b)
+
+{- coverage extension block -}
+module Extra.One where
+module Extra.Two where
+module Extra.Three where
+module Extra.Four where
+import qualified Data.Set as Set
+type RequestId = Int
+type ResponseId = Int
+class Renderable a where
+class Parsable a where
+class Executable a where
+data Envelope = Envelope String
+
+-- REQ-COVER-SRS-231 START
+-- @REQ-COVER-SRS-231 block 1
+-- @brief Coverage helper construct 1.
+-- @details Provides deterministic fixture-level Doxygen coverage block 1.
+-- @param value Input value for helper construct 1.
+-- @return Output value for helper construct 1.
+reqCoverHaskell1 :: Int -> Int
+reqCoverHaskell1 value = value + 1
+
+-- @REQ-COVER-SRS-231 block 2
+-- @brief Coverage helper construct 2.
+-- @details Provides deterministic fixture-level Doxygen coverage block 2.
+-- @param value Input value for helper construct 2.
+-- @return Output value for helper construct 2.
+reqCoverHaskell2 :: Int -> Int
+reqCoverHaskell2 value = value + 2
+
+-- @REQ-COVER-SRS-231 block 3
+-- @brief Coverage helper construct 3.
+-- @details Provides deterministic fixture-level Doxygen coverage block 3.
+-- @param value Input value for helper construct 3.
+-- @return Output value for helper construct 3.
+reqCoverHaskell3 :: Int -> Int
+reqCoverHaskell3 value = value + 3
+
+-- @REQ-COVER-SRS-231 block 4
+-- @brief Coverage helper construct 4.
+-- @details Provides deterministic fixture-level Doxygen coverage block 4.
+-- @param value Input value for helper construct 4.
+-- @return Output value for helper construct 4.
+reqCoverHaskell4 :: Int -> Int
+reqCoverHaskell4 value = value + 4
+
+-- @REQ-COVER-SRS-231 block 5
+-- @brief Coverage helper construct 5.
+-- @details Provides deterministic fixture-level Doxygen coverage block 5.
+-- @param value Input value for helper construct 5.
+-- @return Output value for helper construct 5.
+reqCoverHaskell5 :: Int -> Int
+reqCoverHaskell5 value = value + 5
+
+-- REQ-COVER-SRS-231 END