+
+
package main
+
+import "errors"
+
+// Chunk splits a slice into chunks of specified size
+func Chunk(slice []int, size int) ([][]int, error) {
+ if size <= 0 {
+ return nil, errors.New("chunk size must be positive")
+ }
+
+ chunks := [][]int{}
+ for i := 0; i < len(slice); i += size {
+ end := i + size
+ if end > len(slice) {
+ end = len(slice)
+ }
+ chunks = append(chunks, slice[i:end])
+ }
+ return chunks, nil
+}
+
+// Unique returns a slice with duplicate elements removed
+func Unique(slice []int) []int {
+ seen := make(map[int]bool)
+ result := []int{}
+
+ for _, val := range slice {
+ if !seen[val] {
+ seen[val] = true
+ result = append(result, val)
+ }
+ }
+ return result
+}
+
+// Flatten flattens a 2D slice into a 1D slice
+func Flatten(slice [][]int) []int {
+ result := []int{}
+ for _, subSlice := range slice {
+ result = append(result, subSlice...)
+ }
+ return result
+}
+
+// Sum returns the sum of all elements in a slice
+func Sum(slice []int) int {
+ total := 0
+ for _, val := range slice {
+ total += val
+ }
+ return total
+}
+
+// Max returns the maximum value in a slice
+func Max(slice []int) (int, error) {
+ if len(slice) == 0 {
+ return 0, errors.New("slice is empty")
+ }
+
+ max := slice[0]
+ for _, val := range slice[1:] {
+ if val > max {
+ max = val
+ }
+ }
+ return max, nil
+}
+
+// Min returns the minimum value in a slice
+func Min(slice []int) (int, error) {
+ if len(slice) == 0 {
+ return 0, errors.New("slice is empty")
+ }
+
+ min := slice[0]
+ for _, val := range slice[1:] {
+ if val < min {
+ min = val
+ }
+ }
+ return min, nil
+}
+
+// Reverse reverses a slice
+func Reverse(slice []int) []int {
+ result := make([]int, len(slice))
+ for i, val := range slice {
+ result[len(slice)-1-i] = val
+ }
+ return result
+}
+
+// Filter returns elements that satisfy the predicate
+func Filter(slice []int, predicate func(int) bool) []int {
+ result := []int{}
+ for _, val := range slice {
+ if predicate(val) {
+ result = append(result, val)
+ }
+ }
+ return result
+}
+
+// Map applies a function to each element
+func Map(slice []int, fn func(int) int) []int {
+ result := make([]int, len(slice))
+ for i, val := range slice {
+ result[i] = fn(val)
+ }
+ return result
+}
+
+
+
package main
+
+import "fmt"
+
+func main() {
+ fmt.Println("Coverage Demo Application")
+
+ // Example usage
+ userService := NewUserService()
+ user, err := userService.CreateUser("test@example.com", "Test User", 25)
+ if err != nil {
+ fmt.Printf("Error: %v\n", err)
+ return
+ }
+
+ fmt.Printf("Created user: %s (%s)\n", user.Name, user.Email)
+}
+
+
+
package main
+
+import (
+ "errors"
+ "math"
+)
+
+// Clamp restricts a value to be within a specified range
+func Clamp(value, min, max float64) float64 {
+ if value < min {
+ return min
+ }
+ if value > max {
+ return max
+ }
+ return value
+}
+
+// Average calculates the mean of a slice of numbers
+func Average(numbers []float64) float64 {
+ if len(numbers) == 0 {
+ return 0
+ }
+ sum := 0.0
+ for _, num := range numbers {
+ sum += num
+ }
+ return sum / float64(len(numbers))
+}
+
+// Median calculates the median of a slice of numbers
+func Median(numbers []float64) float64 {
+ if len(numbers) == 0 {
+ return 0
+ }
+
+ // Create a copy and sort it
+ sorted := make([]float64, len(numbers))
+ copy(sorted, numbers)
+
+ // Simple bubble sort for demonstration
+ for i := 0; i < len(sorted); i++ {
+ for j := i + 1; j < len(sorted); j++ {
+ if sorted[i] > sorted[j] {
+ sorted[i], sorted[j] = sorted[j], sorted[i]
+ }
+ }
+ }
+
+ mid := len(sorted) / 2
+ if len(sorted)%2 == 0 {
+ return (sorted[mid-1] + sorted[mid]) / 2
+ }
+ return sorted[mid]
+}
+
+// Factorial calculates the factorial of n
+func Factorial(n int) (int, error) {
+ if n < 0 {
+ return 0, errors.New("factorial is not defined for negative numbers")
+ }
+ if n == 0 || n == 1 {
+ return 1, nil
+ }
+ result := 1
+ for i := 2; i <= n; i++ {
+ result *= i
+ }
+ return result, nil
+}
+
+// IsPrime checks if a number is prime
+func IsPrime(n int) bool {
+ if n < 2 {
+ return false
+ }
+ if n == 2 {
+ return true
+ }
+ if n%2 == 0 {
+ return false
+ }
+
+ sqrt := int(math.Sqrt(float64(n)))
+ for i := 3; i <= sqrt; i += 2 {
+ if n%i == 0 {
+ return false
+ }
+ }
+ return true
+}
+
+// GCD calculates the greatest common divisor
+func GCD(a, b int) int {
+ a = abs(a)
+ b = abs(b)
+
+ for b != 0 {
+ a, b = b, a%b
+ }
+ return a
+}
+
+// LCM calculates the least common multiple
+func LCM(a, b int) int {
+ if a == 0 || b == 0 {
+ return 0
+ }
+ return abs(a*b) / GCD(a, b)
+}
+
+// Abs returns the absolute value
+func abs(n int) int {
+ if n < 0 {
+ return -n
+ }
+ return n
+}
+
+// Power calculates base^exponent
+func Power(base, exponent int) int {
+ if exponent == 0 {
+ return 1
+ }
+ if exponent < 0 {
+ return 0 // Integer division would give 0 anyway
+ }
+
+ result := 1
+ for i := 0; i < exponent; i++ {
+ result *= base
+ }
+ return result
+}
+
+// IsEven checks if a number is even
+func IsEven(n int) bool {
+ return n%2 == 0
+}
+
+// IsOdd checks if a number is odd
+func IsOdd(n int) bool {
+ return n%2 != 0
+}
+
+
+
package main
+
+import (
+ "regexp"
+ "strings"
+)
+
+// Capitalize returns a string with the first letter capitalized
+func Capitalize(s string) string {
+ if s == "" {
+ return ""
+ }
+ return strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
+}
+
+// Truncate shortens a string to maxLength, adding "..." if truncated
+func Truncate(s string, maxLength int) string {
+ if s == "" {
+ return ""
+ }
+ if len(s) <= maxLength {
+ return s
+ }
+ if maxLength <= 3 {
+ return "..."
+ }
+ return s[:maxLength-3] + "..."
+}
+
+// Slugify converts a string to a URL-friendly slug
+func Slugify(s string) string {
+ s = strings.ToLower(s)
+ s = strings.TrimSpace(s)
+
+ // Remove non-alphanumeric characters except spaces and hyphens
+ reg := regexp.MustCompile(`[^\w\s-]`)
+ s = reg.ReplaceAllString(s, "")
+
+ // Replace spaces and underscores with hyphens
+ reg = regexp.MustCompile(`[\s_-]+`)
+ s = reg.ReplaceAllString(s, "-")
+
+ // Remove leading and trailing hyphens
+ s = strings.Trim(s, "-")
+
+ return s
+}
+
+// IsEmail checks if a string is a valid email format
+func IsEmail(s string) bool {
+ emailRegex := regexp.MustCompile(`^[^\s@]+@[^\s@]+\.[^\s@]+$`)
+ return emailRegex.MatchString(s)
+}
+
+// CountWords returns the number of words in a string
+func CountWords(s string) int {
+ if s == "" {
+ return 0
+ }
+ words := strings.Fields(s)
+ return len(words)
+}
+
+// ReverseString reverses a string
+func ReverseString(s string) string {
+ runes := []rune(s)
+ for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
+ runes[i], runes[j] = runes[j], runes[i]
+ }
+ return string(runes)
+}
+
+// IsPalindrome checks if a string is a palindrome
+func IsPalindrome(s string) bool {
+ // Remove non-alphanumeric and convert to lowercase
+ reg := regexp.MustCompile(`[^a-z0-9]`)
+ cleaned := reg.ReplaceAllString(strings.ToLower(s), "")
+
+ for i := 0; i < len(cleaned)/2; i++ {
+ if cleaned[i] != cleaned[len(cleaned)-1-i] {
+ return false
+ }
+ }
+ return true
+}
+
+// Contains checks if a string contains a substring
+func Contains(s, substr string) bool {
+ return strings.Contains(s, substr)
+}
+
+// Repeat repeats a string n times
+func Repeat(s string, n int) string {
+ if n < 0 {
+ return ""
+ }
+ return strings.Repeat(s, n)
+}
+
+
+
package main
+
+import (
+ "errors"
+ "fmt"
+ "time"
+)
+
+// User represents a user in the system
+type User struct {
+ ID string
+ Email string
+ Name string
+ Age int
+ IsActive bool
+ CreatedAt time.Time
+}
+
+// UserService manages user operations
+type UserService struct {
+ users map[string]*User
+ idCounter int
+}
+
+// NewUserService creates a new UserService
+func NewUserService() *UserService {
+ return &UserService{
+ users: make(map[string]*User),
+ idCounter: 1,
+ }
+}
+
+// CreateUser creates a new user
+func (s *UserService) CreateUser(email, name string, age int) (*User, error) {
+ if email == "" || name == "" {
+ return nil, errors.New("email and name are required")
+ }
+ if age < 0 || age > 150 {
+ return nil, errors.New("invalid age")
+ }
+ if !IsEmail(email) {
+ return nil, errors.New("invalid email format")
+ }
+
+ id := fmt.Sprintf("user_%d", s.idCounter)
+ s.idCounter++
+
+ user := &User{
+ ID: id,
+ Email: email,
+ Name: name,
+ Age: age,
+ IsActive: true,
+ CreatedAt: time.Now(),
+ }
+
+ s.users[id] = user
+ return user, nil
+}
+
+// GetUserByID retrieves a user by ID
+func (s *UserService) GetUserByID(id string) (*User, error) {
+ user, exists := s.users[id]
+ if !exists {
+ return nil, errors.New("user not found")
+ }
+ return user, nil
+}
+
+// UpdateUser updates user information
+func (s *UserService) UpdateUser(id string, email, name string, age int, isActive bool) (*User, error) {
+ user, exists := s.users[id]
+ if !exists {
+ return nil, errors.New("user not found")
+ }
+
+ if age < 0 || age > 150 {
+ return nil, errors.New("invalid age")
+ }
+ if email != "" && !IsEmail(email) {
+ return nil, errors.New("invalid email format")
+ }
+
+ if email != "" {
+ user.Email = email
+ }
+ if name != "" {
+ user.Name = name
+ }
+ user.Age = age
+ user.IsActive = isActive
+
+ return user, nil
+}
+
+// DeleteUser removes a user
+func (s *UserService) DeleteUser(id string) error {
+ if _, exists := s.users[id]; !exists {
+ return errors.New("user not found")
+ }
+ delete(s.users, id)
+ return nil
+}
+
+// GetAllUsers returns all users
+func (s *UserService) GetAllUsers() []*User {
+ users := make([]*User, 0, len(s.users))
+ for _, user := range s.users {
+ users = append(users, user)
+ }
+ return users
+}
+
+// GetActiveUsers returns only active users
+func (s *UserService) GetActiveUsers() []*User {
+ users := []*User{}
+ for _, user := range s.users {
+ if user.IsActive {
+ users = append(users, user)
+ }
+ }
+ return users
+}
+
+// GetUsersByAgeRange returns users within an age range
+func (s *UserService) GetUsersByAgeRange(minAge, maxAge int) []*User {
+ users := []*User{}
+ for _, user := range s.users {
+ if user.Age >= minAge && user.Age <= maxAge {
+ users = append(users, user)
+ }
+ }
+ return users
+}
+
+// SearchUsersByName searches users by name
+func (s *UserService) SearchUsersByName(query string) []*User {
+ users := []*User{}
+ for _, user := range s.users {
+ if Contains(user.Name, query) {
+ users = append(users, user)
+ }
+ }
+ return users
+}
+
+// CountUsers returns the total number of users
+func (s *UserService) CountUsers() int {
+ return len(s.users)
+}
+
+
+