pi-usereq 0.49.0 → 0.50.0

package/tests/fixtures_attended_results/project/compress.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ src/fixture_c.c | c\n> Lines: 14-355\n```\n#include \"myheader.h\"\n#include <stdarg.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#define MAX_SIZE 100\n#define CLAMP(val, lo, hi) ((val) < (lo) ? (lo) : ((val) > (hi) ? (hi) : (val)))\n#define STRINGIFY(x) #x\n#define CONCAT(a, b) a##b\n#ifdef DEBUG\n#define LOG(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)\n#else\n#define LOG(fmt, ...) ((void)0)\n#endif\ntypedef int my_int;\ntypedef unsigned char byte_t;\nstruct Point {\nint x;\nint y;\n};\nstruct PackedFlags {\nunsigned int readable : 1;\nunsigned int writable : 1;\nunsigned int executable : 1;\nunsigned int reserved : 5;\n};\nstruct Node {\nunion {\nint i_val;\nfloat f_val;\n} payload;\nstruct Node *next;\n};\nunion Data {\nint i;\nfloat f;\nchar s[16];\n};\nenum Color {\nRED,\nGREEN,\nBLUE\n};\ntypedef int (*comparator_fn)(const void *a, const void *b);\ntypedef int (*transform_fn)(int value);\ntypedef struct {\nconst char *name;\ncomparator_fn handler;\nint priority;\n} callback_entry_t;\nstatic int counter = 0;\nstatic char error_buffer[256] = {0};\nstatic inline int min_val(int a, int b) { return a < b ? a : b; }\nvoid greet(const char *name) {\nif (name == NULL) {\nreturn;\n}\nprintf(\"Hello %s\\n\", name);\n}\nint main(int argc, char **argv) {\nif (argc < 2) {\nfprintf(stderr, \"Usage: %s <name>\\n\", argv[0]);\nreturn 1;\n}\ngreet(argv[1]);\nreturn 0;\n}\nint sum_ints(int count, ...) {\nva_list ap;\nva_start(ap, count);\nint total = 0;\nfor (int i = 0; i < count; i++) {\ntotal += va_arg(ap, int);\n}\nva_end(ap);\nreturn total;\n}\nvoid apply_transform(int *arr, size_t len, transform_fn fn) {\nfor (size_t i = 0; i < len; i++) {\narr[i] = fn(arr[i]);\n}\n}\nunsigned long factorial(unsigned int n) {\nif (n <= 1) {\nreturn 1;\n}\nreturn n * factorial(n - 1);\n}\nstatic void fast_copy(void *restrict dest, const void *restrict src, size_t n) {\nmemcpy(dest, src, n);\n}\nstatic int read_volatile(volatile int *reg) { return *reg; }\nint sum_fixed(int arr[static 10]) {\nint s = 0;\nfor (int i = 0; i < 10; i++) {\ns += arr[i];\n}\nreturn s;\n}\nstruct Vector2 {\nint x;\nint y;\n};\nstruct Matrix2 {\nint a11;\nint a22;\n};\nenum StatusCode { STATUS_OK, STATUS_ERR, STATUS_UNKNOWN };\nenum LevelCode { LEVEL_LOW, LEVEL_MEDIUM, LEVEL_HIGH };\nenum ModeCode { MODE_A, MODE_B };\nenum FlagCode { FLAG_ON, FLAG_OFF };\nunion NumberValue {\nint i;\nfloat f;\n};\nunion PtrValue {\nvoid *p;\nlong l;\n};\nunion StateValue {\nint s;\nchar c;\n};\nunion PairValue {\nint x;\nint y;\n};\ntypedef long index_t;\ntypedef float ratio_t;\ntypedef struct Point point_t;\ntypedef double score_t;\nint req_cover_c_1(int value) { return value + 1; }\nint req_cover_c_2(int value) { return value + 2; }\nint req_cover_c_3(int value) { return value + 3; }\nint req_cover_c_4(int value) { return value + 4; }\nint req_cover_c_5(int value) { return value + 5; }\n```\n\n@@@ src/fixture_cpp.cpp | cpp\n> Lines: 13-402\n```\n#include <concepts>\n#include <functional>\n#include <iostream>\n#include <memory>\n#include <optional>\n#include <string>\n#include <vector>\n#define VERSION 2\n#define LIKELY(x) __builtin_expect(!!(x), 1)\nnamespace MyNS {\ntemplate <typename T>\nconcept Printable = requires(std::ostream &os, T val) {\n{ os << val } -> std::same_as<std::ostream &>;\n};\ntemplate <typename T>\nconcept Numeric = std::integral<T> || std::floating_point<T>;\ntemplate <Printable T> class Container {\npublic:\nT value;\nexplicit Container(T v) : value(std::move(v)) {}\nContainer(const Container &other) = default;\nContainer(Container &&other) noexcept = default;\nContainer &operator=(const Container &other) = default;\nContainer &operator=(Container &&other) noexcept = default;\n~Container() = default;\nfriend std::ostream &operator<<(std::ostream &os, const Container &c) {\nreturn os << c.value;\n}\nbool operator==(const Container &other) const { return value == other.value; }\n};\nstruct Point {\ndouble x;\ndouble y;\nconstexpr double dist_sq(const Point &other) const {\ndouble dx = x - other.x;\ndouble dy = y - other.y;\nreturn dx * dx + dy * dy;\n}\nconstexpr Point operator+(const Point &rhs) const {\nreturn {x + rhs.x, y + rhs.y};\n}\n};\nenum class Direction {\nUp,\nDown,\nLeft,\nRight\n};\nusing StringVec = std::vector<std::string>;\ntypedef int my_int_t;\nusing Callback = std::function<void(int)>;\ntemplate <typename Derived> class Cloneable {\npublic:\nstd::unique_ptr<Derived> clone() const {\nreturn std::make_unique<Derived>(static_cast<const Derived &>(*this));\n}\n};\nclass Base {\npublic:\nvirtual const char *type_name() const = 0;\nvirtual ~Base() = default;\n};\nclass DerivedA : public virtual Base {\npublic:\nconst char *type_name() const override { return \"DerivedA\"; }\n};\nclass DerivedB : public virtual Base {\npublic:\nconst char *type_name() const override { return \"DerivedB\"; }\n};\nclass Diamond : public DerivedA, public DerivedB {\npublic:\nconst char *type_name() const override { return \"Diamond\"; }\n};\nconstexpr unsigned long long constexpr_factorial(unsigned int n) {\nreturn n <= 1 ? 1ULL : n * constexpr_factorial(n - 1);\n}\nstd::pair<std::string, std::string> parse_kv(const std::string &input) {\nauto pos = input.find('=');\nif (pos == std::string::npos) {\nreturn {\"\", \"\"};\n}\nreturn {input.substr(0, pos), input.substr(pos + 1)};\n}\nvoid greet(std::string name) { std::cout << \"Hello, \" << name << \"\\n\"; }\nint main() {\nauto [key, val] = parse_kv(\"lang=cpp\");\ngreet(key);\nreturn 0;\n}\nconstexpr auto square = [](auto x) { return x * x; };\nnamespace Inner::Detail {\ninline std::string format_int(int v) { return std::to_string(v); }\n}\n}\ntemplate <MyNS::Numeric T> std::string serialize(T value) {\nreturn std::to_string(value);\n}\ninline std::string serialize(const std::string &value) { return value; }\nstruct Pixel {\nint r;\nint g;\nint b;\n};\nstruct Size {\nint w;\nint h;\n};\nstruct Bounds {\nint x;\nint y;\nint w;\nint h;\n};\nstruct Marker {\nint id;\n};\nenum Mode { ModeA, ModeB };\nenum State { StateIdle, StateBusy };\nenum Grade { GradeA, GradeB };\nenum Severity { SevLow, SevHigh };\nnamespace extns {\ninline int add_one(int v) { return v + 1; }\n}\nnamespace ext_alpha {\ninline int ping() { return 1; }\n}\nnamespace ext_beta {\ninline int pong() { return 2; }\n}\n#define FEATURE_ALPHA 1\n#define FEATURE_BETA 2\n#define FEATURE_GAMMA 3\nusing NumberVec = std::vector<int>;\ntypedef long LongId;\nint req_cover_cpp_1(int value) { return value + 1; }\nint req_cover_cpp_2(int value) { return value + 2; }\nint req_cover_cpp_3(int value) { return value + 3; }\nint req_cover_cpp_4(int value) { return value + 4; }\nint req_cover_cpp_5(int value) { return value + 5; }\n```\n\n@@@ src/fixture_csharp.cs | csharp\n> Lines: 9-410\n```\nusing System;\nusing System.Collections.Generic;\nusing System.Linq;\nusing System.Threading.Tasks;\nusing System.Threading;\nnamespace MyApp {\npublic delegate void DataChangedHandler(object sender, string data);\npublic delegate T Transform<T>(T value);\n[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]\npublic class AuditableAttribute : Attribute {\npublic int Level { get; set; } = 1;\n}\n[Serializable]\n[Auditable(Level = 2)]\npublic class Person : IComparable<Person>, IDisposable {\npublic const int MAX_AGE = 150;\nprivate static int _instanceCount = 0;\nprivate string _name;\npublic string Name {\nget => _name;\nset {\nif (string.IsNullOrWhiteSpace(value))\nthrow new ArgumentException(\"Name cannot be empty\");\n_name = value;\n}\n}\npublic int Age { get; init; }\npublic string? Email { get; set; }\npublic Guid Id { get; } = Guid.NewGuid();\npublic event DataChangedHandler? OnDataChanged;\npublic Person(string name, int age) {\n_name = name;\nAge = age;\nInterlocked.Increment(ref _instanceCount);\n}\npublic void Greet() {\nOnDataChanged?.Invoke(this, $\"Greeted {Name}\");\nConsole.WriteLine($\"Hello, {Name}!\");\n}\npublic static async Task<string> FetchAsync(CancellationToken token = default) {\nawait Task.Delay(100, token);\nreturn \"data\";\n}\npublic int CompareTo(Person? other) {\nif (other is null) return 1;\nreturn Age.CompareTo(other.Age);\n}\npublic void Dispose() {\nInterlocked.Decrement(ref _instanceCount);\nGC.SuppressFinalize(this);\n}\npublic object? this[string propertyName] {\nget {\nreturn propertyName switch {\n\"Name\" => Name,\n\"Age\" => Age,\n\"Email\" => Email,\n_ => null,\n};\n}\n}\npublic void Deconstruct(out string name, out int age) {\nname = Name;\nage = Age;\n}\npublic static int GetInstanceCount() => _instanceCount;\n}\npublic interface IGreeter {\nvoid SayHello(string name);\nvoid SayGoodbye(string name) {\nConsole.WriteLine($\"Goodbye, {name}\");\n}\n}\npublic interface IRepository<T> where T : class, new() {\nTask<T?> FindByIdAsync(int id);\nIAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\nTask<bool> SaveAsync(T entity);\n}\npublic readonly struct Point {\npublic double X { get; init; }\npublic double Y { get; init; }\npublic static Point operator +(Point a, Point b) => new() { X = a.X + b.X, Y = a.Y + b.Y };\npublic double Magnitude => Math.Sqrt(X * X + Y * Y);\n}\n[Flags]\npublic enum Color {\nNone = 0,\nRed = 1,\nGreen = 2,\nBlue = 4,\nAll = Red | Green | Blue,\n}\npublic record ConfigEntry(string Key, string Value);\npublic record struct Vector2(double X, double Y);\npublic static class StringExtensions {\npublic static string Truncate(this string str, int maxLength) {\nif (str.Length <= maxLength) return str;\nreturn str[..maxLength] + \"...\";\n}\npublic static bool IsAscii(this string str) {\nreturn str.All(c => c < 128);\n}\n}\npublic class SortedCollection<T> where T : IComparable<T> {\nprivate readonly List<T> _items = new();\npublic void Add(T item) {\nvar index = _items.BinarySearch(item);\nif (index < 0) index = ~index;\n_items.Insert(index, item);\n}\npublic IEnumerable<T> Where(Func<T, bool> predicate) {\nreturn _items.Where(predicate);\n}\n}\npublic static class PatternMatcher {\npublic static string Describe(object? obj) {\nreturn obj switch {\nnull => \"null\",\nint i when i > 0 => $\"positive int: {i}\",\nint i => $\"non-positive int: {i}\",\nstring { Length: 0 } => \"empty string\",\nstring s => $\"string({s.Length}): {s}\",\nPerson { Age: >= 18 } p => $\"adult: {p.Name}\",\nPerson p => $\"minor: {p.Name}\",\n_ => $\"unknown: {obj.GetType().Name}\",\n};\n}\n}\n}\nnamespace MyApp.Services {}\nnamespace MyApp.Core {}\nnamespace MyApp.Data {}\nnamespace MyApp.Api {}\npublic interface ILogger {}\npublic interface IParser {}\npublic interface IRunner {}\npublic enum ModeCs { Fast, Safe }\npublic enum PhaseCs { Init, Done }\npublic enum StateCs { Open, Closed }\npublic enum SignalCs { On, Off }\npublic struct Size { public int W; public int H; }\npublic readonly struct Vector { public readonly int X; public readonly int Y; }\npublic struct Limits { public int Max; }\npublic struct Cursor { public int Index; }\n[DebuggerDisplay(\"{Value}\")]\npublic const int MIN_AGE = 10;\npublic const int RETRY_LIMIT = 3;\npublic const int CACHE_SIZE = 128;\npublic const int DEFAULT_PAGE = 1;\npublic static class ReqCoverCsharp {\npublic static int ReqCoverCsharp1(int value) { return value + 1; }\npublic static int ReqCoverCsharp2(int value) { return value + 2; }\npublic static int ReqCoverCsharp3(int value) { return value + 3; }\npublic static int ReqCoverCsharp4(int value) { return value + 4; }\npublic static int ReqCoverCsharp5(int value) { return value + 5; }\n}\n```\n\n@@@ src/fixture_elixir.ex | elixir\n> Lines: 10-408\n```\ndefmodule MyApp.Server do\n  @moduledoc \"\"\"\n  GenServer implementation for managing application state.\n  Handles synchronous calls, asynchronous casts, and info messages.\n  Supports state initialization with validated options.\n  \"\"\"\n  use GenServer\n  import Enum\n  alias MyApp.Config\n  alias MyApp.Server.State\n  require Logger\n  @behaviour GenServer\n  @default_timeout 5_000\n  @max_items 1_000\n  @doc \"\"\"\n  Internal state struct for the server.\n  @field name Server instance name.\n  @field port Listening port number.\n  @field items List of stored items.\n  @field started_at Timestamp of server start.\n  \"\"\"\n  defstruct [:name, :port, items: [], started_at: nil]\n  @type t :: %__MODULE__{\n    name: String.t(),\n    port: non_neg_integer(),\n    items: list(any()),\n    started_at: DateTime.t() | nil\n  }\n  @type option :: {:name, String.t()} | {:port, non_neg_integer()}\n  @doc \"\"\"\n  Start a new server process linked to the caller.\n  @param opts Keyword list of options (:name, :port).\n  @return {:ok, pid} on success or {:error, reason} on failure.\n  \"\"\"\n  @spec start_link(keyword()) :: GenServer.on_start()\n  def start_link(opts) do\n    name = Keyword.get(opts, :name, \"default\")\n    GenServer.start_link(__MODULE__, opts, name: via_tuple(name))\n  end\n  @doc \"\"\"\n  Add an item to the server's collection.\n  @param server The server PID or registered name.\n  @param item The item to store.\n  @return :ok\n  \"\"\"\n  @spec add_item(GenServer.server(), any()) :: :ok\n  def add_item(server, item) do\n    GenServer.call(server, {:add_item, item})\n  end\n  @doc \"\"\"\n  Retrieve all stored items.\n  @param server The server PID or registered name.\n  @return List of stored items.\n  \"\"\"\n  @spec get_items(GenServer.server()) :: list(any())\n  def get_items(server) do\n    GenServer.call(server, :get_items)\n  end\n  @doc \"\"\"\n  Asynchronously notify the server of an event.\n  @param server The server PID.\n  @param event The event data to process.\n  @return :ok\n  \"\"\"\n  @spec notify(GenServer.server(), any()) :: :ok\n  def notify(server, event) do\n    GenServer.cast(server, {:notify, event})\n  end\n  defp via_tuple(name) do\n    {:via, Registry, {MyApp.Registry, name}}\n  end\n  @impl true\n  def init(opts) do\n    name = Keyword.fetch!(opts, :name)\n    port = Keyword.get(opts, :port, 4000)\n    state = %__MODULE__{\n      name: name,\n      port: port,\n      started_at: DateTime.utc_now()\n    }\n    Logger.info(\"Server #{name} started on port #{port}\")\n    {:ok, state}\n  end\n  @impl true\n  def handle_call({:add_item, item}, _from, state) do\n    if length(state.items) >= @max_items do\n      {:reply, {:error, :capacity_exceeded}, state}\n    else\n      new_state = %{state | items: [item | state.items]}\n      {:reply, :ok, new_state}\n    end\n  end\n  @impl true\n  def handle_call(:get_items, _from, state) do\n    {:reply, Enum.reverse(state.items), state}\n  end\n  @impl true\n  def handle_cast({:notify, event}, state) do\n    Logger.debug(\"Received event: #{inspect(event)}\")\n    {:noreply, state}\n  end\n  @impl true\n  def handle_info(:timeout, state) do\n    Logger.warn(\"Server #{state.name} timed out\")\n    {:noreply, state}\n  end\n  defp handle_internal(state) do\n    pruned = Enum.take(state.items, @max_items)\n    %{state | items: pruned}\n  end\n  @doc \"\"\"\n  Define a macro for compile-time code generation.\n  @param expr The expression to wrap.\n  @return Quoted AST wrapping the expression.\n  \"\"\"\n  defmacro my_macro(expr) do\n    quote do\n      result = unquote(expr)\n      Logger.debug(\"Macro result: #{inspect(result)}\")\n      result\n    end\n  end\nend\ndefprotocol Printable do\n  @moduledoc \"\"\"\n  Protocol for types that can be printed as formatted strings.\n  \"\"\"\n  @doc \"\"\"\n  Convert a value to its formatted string representation.\n  @param data The value to format.\n  @return Formatted string.\n  \"\"\"\n  @spec print(t) :: String.t()\n  def print(data)\nend\ndefimpl Printable, for: MyApp.Server do\n  @doc \"\"\"\n  Format a server struct for display.\n  @param server The server struct to format.\n  @return String in format \"Server(name:port)\".\n  \"\"\"\n  def print(server) do\n    \"Server(#{server.name}:#{server.port})\"\n  end\nend\ndefimpl Printable, for: BitString do\n  def print(str) do\n    \"String(#{str})\"\n  end\nend\ndefmodule MyApp.Utils do\n  @moduledoc \"\"\"\n  Utility functions demonstrating pattern matching, guards,\n  pipe operators, and comprehensions.\n  \"\"\"\n  @doc \"\"\"\n  Classify a value using guard clauses and pattern matching.\n  @param value The value to classify.\n  @return Atom describing the value's category.\n  \"\"\"\n  @spec classify(any()) :: atom()\n  def classify(value) when is_integer(value) and value > 0, do: :positive\n  def classify(value) when is_integer(value) and value < 0, do: :negative\n  def classify(0), do: :zero\n  def classify(value) when is_binary(value), do: :string\n  def classify(value) when is_list(value), do: :list\n  def classify(_), do: :unknown\n  @doc \"\"\"\n  Process a list using pipe operator for data transformation.\n  @param items List of strings to process.\n  @return Sorted list of unique uppercase strings.\n  \"\"\"\n  @spec process_list(list(String.t())) :: list(String.t())\n  def process_list(items) do\n    items\n    |> Enum.map(&String.trim/1)\n    |> Enum.reject(&(&1 == \"\"))\n    |> Enum.map(&String.upcase/1)\n    |> Enum.uniq()\n    |> Enum.sort()\n  end\n  @doc \"\"\"\n  Demonstrate for-comprehension with multiple generators and filters.\n  @param range Upper bound for the search space.\n  @return List of Pythagorean triples.\n  \"\"\"\n  @spec pythagorean_triples(pos_integer()) :: list(tuple())\n  def pythagorean_triples(range) do\n    for a <- 1..range,\n        b <- a..range,\n        c <- b..range,\n        a * a + b * b == c * c do\n      {a, b, c}\n    end\n  end\n  @doc \"\"\"\n  Safe division returning :error tuple on zero divisor.\n  @param a Dividend.\n  @param b Divisor.\n  @return {:ok, result} or {:error, :division_by_zero}.\n  \"\"\"\n  @spec safe_divide(number(), number()) :: {:ok, float()} | {:error, atom()}\n  def safe_divide(_, 0), do: {:error, :division_by_zero}\n  def safe_divide(a, b), do: {:ok, a / b}\n  @doc \"\"\"\n  Recursively compute factorial with guard clause.\n  @param n Non-negative integer.\n  @return Factorial of n.\n  \"\"\"\n  @spec factorial(non_neg_integer()) :: pos_integer()\n  def factorial(0), do: 1\n  def factorial(n) when n > 0, do: n * factorial(n - 1)\nend\ndefmodule MyApp.Plugin do\n  @moduledoc \"\"\"\n  Behaviour defining the plugin interface.\n  \"\"\"\n  @doc \"Initialize the plugin with configuration options.\"\n  @callback init(opts :: keyword()) :: {:ok, any()} | {:error, String.t()}\n  @doc \"Execute the plugin's main logic.\"\n  @callback execute(state :: any()) :: :ok | {:error, String.t()}\n  @doc \"Clean up plugin resources.\"\n  @callback cleanup(state :: any()) :: :ok\n  @optional_callbacks [cleanup: 1]\nend\ndefmodule MyApp.Extra do\n  defstruct [:name]\nend\ndefmodule MyApp.Audit do\n  defstruct [:id]\nend\ndefmodule MyApp.State do\n  defstruct [:status]\nend\ndefmodule MyApp.Payload do\n  defstruct [:value]\nend\ndefmodule MyApp.Context do\n  defstruct [:meta]\nend\ndefprotocol Auditable do\n  def audit(data)\nend\ndefprotocol Renderable do\n  def render(data)\nend\ndefprotocol Parsable do\n  def parse(data)\nend\ndefprotocol Validatable do\n  def validate(data)\nend\ndefimpl Auditable, for: Any do\n  def audit(data), do: data\nend\ndefimpl Renderable, for: Any do\n  def render(data), do: data\nend\ndefimpl Parsable, for: Any do\n  def parse(data), do: data\nend\ndefimpl Validatable, for: Any do\n  def validate(data), do: data\nend\ndefmodule ReqCoverElixir do\n  def req_cover_elixir_1(value), do: value + 1\n  def req_cover_elixir_2(value), do: value + 2\n  def req_cover_elixir_3(value), do: value + 3\n  def req_cover_elixir_4(value), do: value + 4\n  def req_cover_elixir_5(value), do: value + 5\nend\n```\n\n@@@ src/fixture_go.go | go\n> Lines: 12-339\n```\npackage main\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"io\"\n\t\"sync\"\n)\nconst MaxSize = 100\nvar globalVar = 0\nconst (\n\tLogDebug = iota\n\tLogInfo\n\tLogError\n)\ntype Server struct {\n\tPort int\n\tHost string\n\tsync.Mutex\n\thandlers map[string]HandlerFunc\n}\ntype HandlerFunc func(ctx context.Context, req []byte) ([]byte, error)\ntype Address struct {\n\tStreet string\n\tCity   string\n\tZip    string\n}\ntype Employee struct {\n\tName    string\n\tAge     int\n\tAddress\n\tManager *Employee\n}\ntype Handler interface {\n\tHandle(ctx context.Context, data []byte) error\n}\ntype ReadWriteCloser interface {\n\tio.Reader\n\tio.Writer\n\tio.Closer\n}\ntype MyInt int\nfunc (m MyInt) String() string {\n\treturn fmt.Sprintf(\"MyInt(%d)\", int(m))\n}\ntype Pair[A any, B any] struct {\n\tFirst  A\n\tSecond B\n}\ntype Ordered interface {\n\t~int | ~float64 | ~string\n}\nfunc main() {\n\tfmt.Println(\"hello\")\n}\nfunc init() {\n\tglobalVar = 1\n}\nfunc (s *Server) Start() error {\n\ts.Lock()\n\tdefer s.Unlock()\n\tif s.Port <= 0 {\n\t\treturn fmt.Errorf(\"invalid port: %d\", s.Port)\n\t}\n\tfmt.Printf(\"Starting on %s:%d\\n\", s.Host, s.Port)\n\treturn nil\n}\nfunc (s *Server) Register(path string, handler HandlerFunc) {\n\tif s.handlers == nil {\n\t\ts.handlers = make(map[string]HandlerFunc)\n\t}\n\ts.handlers[path] = handler\n}\nfunc Max[T Ordered](a, b T) T {\n\tif a > b {\n\t\treturn a\n\t}\n\treturn b\n}\nfunc Filter[T any](items []T, pred func(T) bool) []T {\n\tresult := make([]T, 0)\n\tfor _, item := range items {\n\t\tif pred(item) {\n\t\t\tresult = append(result, item)\n\t\t}\n\t}\n\treturn result\n}\nfunc Divide(a, b int) (int, int, error) {\n\tif b == 0 {\n\t\treturn 0, 0, fmt.Errorf(\"division by zero\")\n\t}\n\treturn a / b, a % b, nil\n}\nfunc ParseConfig(input string) (host string, port int, err error) {\n\t_, scanErr := fmt.Sscanf(input, \"%s:%d\", &host, &port)\n\tif scanErr != nil {\n\t\terr = scanErr\n\t\treturn\n\t}\n\treturn\n}\nfunc Counter() func() int {\n\tcount := 0\n\treturn func() int {\n\t\tcount++\n\t\treturn count\n\t}\n}\nfunc FanOut(items []string, workers int) <-chan string {\n\tresults := make(chan string, len(items))\n\tvar wg sync.WaitGroup\n\tfor i := 0; i < workers; i++ {\n\t\twg.Add(1)\n\t\tgo func(id int) {\n\t\t\tdefer wg.Done()\n\t\t\tfor _, item := range items {\n\t\t\t\tresults <- fmt.Sprintf(\"[%d] %s\", id, item)\n\t\t\t}\n\t\t}(i)\n\t}\n\tgo func() {\n\t\twg.Wait()\n\t\tclose(results)\n\t}()\n\treturn results\n}\nfunc Describe(v interface{}) string {\n\tswitch val := v.(type) {\n\tcase int:\n\t\treturn fmt.Sprintf(\"int: %d\", val)\n\tcase string:\n\t\treturn fmt.Sprintf(\"string: %q\", val)\n\tcase bool:\n\t\tif val {\n\t\t\treturn \"bool: true\"\n\t\t}\n\t\treturn \"bool: false\"\n\tcase nil:\n\t\treturn \"nil\"\n\tdefault:\n\t\treturn fmt.Sprintf(\"unknown: %T\", val)\n\t}\n}\nfunc SafeExecute(fn func()) (err error) {\n\tdefer func() {\n\t\tif r := recover(); r != nil {\n\t\t\terr = fmt.Errorf(\"panic: %v\", r)\n\t\t}\n\t}()\n\tfn()\n\treturn nil\n}\npackage utilx\npackage configx\npackage jobsx\npackage metricx\nimport \"os\"\nimport \"time\"\nimport \"strings\"\nimport \"bytes\"\nfunc (s *Server) Stop() {}\nfunc (s *Server) Reset() {}\ntype Session struct { Id string }\ntype Bucket struct { Name string }\ntype Closer interface { Close() error }\ntype Starter interface { Start() error }\ntype UserAlias string\ntype Amount int\ntype Resolver func(string) error\nconst RetryCount = 3\nvar LastError error\nfunc reqCoverGo1(value int) int { return value + 1 }\nfunc reqCoverGo2(value int) int { return value + 2 }\nfunc reqCoverGo3(value int) int { return value + 3 }\nfunc reqCoverGo4(value int) int { return value + 4 }\nfunc reqCoverGo5(value int) int { return value + 5 }\n```\n\n@@@ src/fixture_haskell.hs | haskell\n> Lines: 11-248\n```\nmodule MyModule\n  ( Name\n  , Person(..)\n  , Printable(..)\n  , Expr(..)\n  , greet\n  , safeDiv\n  , processList\n  , fibonacci\n  ) where\nimport Data.List (sort, nub, intercalate)\nimport Data.Maybe (fromMaybe, isJust)\nimport qualified Data.Map as Map\nimport Control.Monad (when, unless, forM_)\ntype Name = String\ntype Config = Map.Map String Int\ntype Transform a = a -> a\ndata Person = Person\n  { personName :: String\n  , personAge  :: Int\n  } deriving (Show, Eq, Ord)\ndata Tree a\n  = Leaf\n  | Node a (Tree a) (Tree a)\n  deriving (Show, Eq)\ndata Expr\n  = Lit Double\n  | Add Expr Expr\n  | Mul Expr Expr\n  | Neg Expr\n  deriving (Show)\ndata Result a\n  = Ok a\n  | Err String\n  deriving (Show)\nclass Printable a where\n  printIt :: a -> String\n  debugPrint :: a -> String\n  debugPrint x = \"Debug: \" ++ printIt x\nclass Serializable a where\n  serialize :: a -> [(String, String)]\ninstance Printable Person where\n  printIt p = personName p ++ \" (\" ++ show (personAge p) ++ \")\"\ninstance Serializable Person where\n  serialize p =\n    [ (\"name\", personName p)\n    , (\"age\", show (personAge p))\n    ]\ninstance Functor Tree where\n  fmap _ Leaf         = Leaf\n  fmap f (Node x l r) = Node (f x) (fmap f l) (fmap f r)\ninstance Functor Result where\n  fmap f (Ok a)  = Ok (f a)\n  fmap _ (Err e) = Err e\ngreet :: String -> String\ngreet name = \"Hello \" ++ name\nsafeDiv :: Double -> Double -> Maybe Double\nsafeDiv _ 0 = Nothing\nsafeDiv x y = Just (x / y)\neval :: Expr -> Double\neval (Lit n)   = n\neval (Add a b) = eval a + eval b\neval (Mul a b) = eval a * eval b\neval (Neg e)   = -(eval e)\nprocessList :: [Int] -> [Int]\nprocessList xs = result\n  where\n    unique = nub xs\n    sorted = sort unique\n    result = filter (> 0) sorted\nfibonacci :: Int -> Integer\nfibonacci n\n  | n < 0     = error \"negative input\"\n  | n == 0    = 0\n  | n == 1    = 1\n  | otherwise = go n 0 1\n  where\n    go 0 a _ = a\n    go k a b = go (k - 1) b (a + b)\ninsertTree :: (Ord a) => a -> Tree a -> Tree a\ninsertTree x Leaf = Node x Leaf Leaf\ninsertTree x (Node y left right)\n  | x < y     = Node y (insertTree x left) right\n  | x > y     = Node y left (insertTree x right)\n  | otherwise  = Node y left right\nfoldTree :: (b -> a -> b) -> b -> Tree a -> b\nfoldTree _ acc Leaf           = acc\nfoldTree f acc (Node x l r) =\n  let leftAcc = foldTree f acc l\n      midAcc  = f leftAcc x\n  in foldTree f midAcc r\nlookupConfig :: Config -> String -> Int -> Int\nlookupConfig cfg key def = fromMaybe def (Map.lookup key cfg)\napplyN :: Int -> Transform a -> a -> a\napplyN 0 _ x = x\napplyN n f x = applyN (n - 1) f (f x)\nformatPersons :: (Printable a) => [a] -> String\nformatPersons ps = intercalate \", \" (map printIt ps)\nsafeCompute :: Double -> Double -> Double -> Maybe Double\nsafeCompute x y z = do\n  a <- safeDiv x y\n  b <- safeDiv a z\n  return (a + b)\nmodule Extra.One where\nmodule Extra.Two where\nmodule Extra.Three where\nmodule Extra.Four where\nimport qualified Data.Set as Set\ntype RequestId = Int\ntype ResponseId = Int\nclass Renderable a where\nclass Parsable a where\nclass Executable a where\ndata Envelope = Envelope String\nreqCoverHaskell1 :: Int -> Int\nreqCoverHaskell1 value = value + 1\nreqCoverHaskell2 :: Int -> Int\nreqCoverHaskell2 value = value + 2\nreqCoverHaskell3 :: Int -> Int\nreqCoverHaskell3 value = value + 3\nreqCoverHaskell4 :: Int -> Int\nreqCoverHaskell4 value = value + 4\nreqCoverHaskell5 :: Int -> Int\nreqCoverHaskell5 value = value + 5\n```\n\n@@@ src/fixture_java.java | java\n> Lines: 11-429\n```\npackage com.example.app;\nimport java.util.List;\nimport java.util.Map;\nimport java.util.Optional;\nimport java.util.function.Function;\nimport java.util.function.Predicate;\nimport java.util.stream.Collectors;\nimport static java.lang.Math.PI;\n@interface RequiresAuth {\nString role() default \"user\";\n}\n@SuppressWarnings(\"unchecked\")\npublic class MyClass<T extends Comparable<T>> {\npublic static final int MAX_SIZE = 100;\nprivate List<T> items;\npublic MyClass(List<T> items) {\nthis.items = items;\n}\npublic void greet(String name) {\nif (name == null) {\nreturn;\n}\nSystem.out.println(\"Hello, \" + name);\n}\nprivate static String helper() {\nreturn \"ok\";\n}\npublic Optional<T> findFirst(Predicate<T> predicate) {\nfor (T item : items) {\nif (predicate.test(item)) {\nreturn Optional.of(item);\n}\n}\nreturn Optional.empty();\n}\npublic <R> List<R> map(Function<T, R> mapper) {\nreturn items.stream()\n.map(mapper)\n.collect(Collectors.toList());\n}\npublic double sumWildcard(List<? extends Number> source) {\ndouble total = 0.0;\nfor (Number n : source) {\ntotal += n.doubleValue();\n}\nreturn total;\n}\npublic class Builder {\nprivate List<T> pending;\npublic Builder add(T item) {\npending.add(item);\nreturn this;\n}\npublic MyClass<T> build() {\nreturn new MyClass<>(pending);\n}\n}\npublic static class Config {\npublic final String key;\npublic final Object value;\npublic Config(String key, Object value) {\nthis.key = key;\nthis.value = value;\n}\n}\n}\npublic interface Greeter {\nvoid sayHello(String name);\ndefault void sayGoodbye(String name) {\nSystem.out.println(\"Goodbye, \" + name);\n}\nstatic Greeter simple() {\nreturn name -> System.out.println(\"Hi, \" + name);\n}\n}\npublic enum Color {\nRED(\"#FF0000\"),\nGREEN(\"#00FF00\"),\nBLUE(\"#0000FF\");\nprivate final String hex;\nColor(String hex) {\nthis.hex = hex;\n}\npublic String getHex() {\nreturn hex;\n}\n}\npublic record Point(double x, double y) {\npublic Point {\nif (Double.isNaN(x) || Double.isNaN(y)) {\nthrow new IllegalArgumentException(\"NaN coordinates\");\n}\n}\npublic double distanceTo(Point other) {\ndouble dx = this.x - other.x;\ndouble dy = this.y - other.y;\nreturn Math.sqrt(dx * dx + dy * dy);\n}\n}\npublic sealed class Shape permits Circle, Rectangle {\npublic double area() {\nreturn 0.0;\n}\n}\npublic final class Circle extends Shape {\nprivate final double radius;\npublic Circle(double radius) {\nthis.radius = radius;\n}\n@Override\npublic double area() {\nreturn PI * radius * radius;\n}\n}\npublic final class Rectangle extends Shape {\nprivate final double width;\nprivate final double height;\npublic Rectangle(double width, double height) {\nthis.width = width;\nthis.height = height;\n}\n@Override\npublic double area() {\nreturn width * height;\n}\n}\npublic class Evaluator {\npublic static String describe(Shape shape) {\nreturn switch (shape) {\ncase Circle c -> \"Circle with radius \" + c.area();\ncase Rectangle r -> \"Rectangle with area \" + r.area();\ndefault -> \"Unknown shape\";\n};\n}\n@RequiresAuth(role = \"admin\")\npublic static String readFile(String path) throws java.io.IOException {\ntry (var reader = new java.io.BufferedReader(new java.io.FileReader(path))) {\nreturn reader.lines().collect(Collectors.joining(\"\\n\"));\n}\n}\n}\npackage com.example.extra.one;\npackage com.example.extra.two;\npackage com.example.extra.three;\npackage com.example.extra.four;\ninterface Runner {}\npublic interface Mapper {}\npublic interface Handler {}\npublic interface Auditor {}\nenum ModeJava { FAST, SAFE }\nenum PhaseJava { INIT, RUN }\nenum StatusJava { OPEN, CLOSED }\nenum KindJava { A, B }\npublic static final int DEFAULT_LIMIT = 10;\npublic static final int RETRY_LIMIT = 3;\npublic static final int BUFFER_SIZE = 512;\npublic static final int MAX_USERS = 99;\n@Trace\nclass ReqCoverJava {\nstatic int reqCoverJava1(int value) { return value + 1; }\nstatic int reqCoverJava2(int value) { return value + 2; }\nstatic int reqCoverJava3(int value) { return value + 3; }\nstatic int reqCoverJava4(int value) { return value + 4; }\nstatic int reqCoverJava5(int value) { return value + 5; }\n}\n```\n\n@@@ src/fixture_javascript.js | javascript\n> Lines: 11-381\n```\nimport React from 'react';\nimport { useState, useEffect } from 'react';\nclass MyComponent {\n#instanceId;\nstatic #registry = new Map();\nstatic {\nconsole.log('MyComponent class loaded');\n}\nconstructor(id = 0) {\nthis.#instanceId = id;\nMyComponent.#registry.set(id, this);\n}\nrender() {\nreturn null;\n}\ngetId() {\nreturn this.#instanceId;\n}\nstatic has(id) {\nreturn MyComponent.#registry.has(id);\n}\n}\nclass EnhancedComponent extends MyComponent {\nrender() {\nsuper.render();\nreturn { type: 'div', children: [] };\n}\ncomponentDidMount() {\nconsole.log('mounted');\n}\n}\nfunction greet(name) {\nreturn \"Hello \" + name;\n}\nasync function fetchData() {\nreturn await fetch('/api');\n}\nconst handler = (event) => {\nevent.preventDefault();\nconsole.log(event.type);\n};\nconst processItems = ({ items, count }) => {\nreturn items.slice(0, count).map(i => i.toUpperCase());\n};\nconst MAX_SIZE = 100;\nconst PLUGIN_KEY = Symbol('plugin');\nconst MyWrapped = React.memo(() => {\nreturn null;\n});\nfunction* idGenerator() {\nlet id = 0;\nwhile (true) {\nyield id++;\n}\n}\nfunction* rangeGenerator(start, end) {\nfor (let i = start; i < end; i++) {\nyield i;\n}\n}\nasync function* asyncDataStream(url) {\nlet page = 0;\nwhile (true) {\nconst response = await fetch(`${url}?page=${page}`);\nconst data = await response.json();\nif (data.length === 0) {\nreturn;\n}\nyield data;\npage++;\n}\n}\nconst initResult = (() => {\nconst config = { debug: false };\nreturn Object.freeze(config);\n})();\nfunction createProxy(target) {\nreturn new Proxy(target, {\nget(obj, prop) {\nconsole.log(`Access: ${String(prop)}`);\nreturn Reflect.get(obj, prop);\n},\nset(obj, prop, value) {\nconsole.log(`Set: ${String(prop)} = ${value}`);\nreturn Reflect.set(obj, prop, value);\n},\n});\n}\nfunction buildDynamic(prefix) {\nreturn {\n[`${prefix}_name`]: 'value',\n[`${prefix}_id`]: 42,\n[Symbol.toPrimitive](hint) {\nreturn hint === 'string' ? prefix : 0;\n},\n};\n}\nfunction fetchAndProcess(url) {\nreturn fetch(url)\n.then(res => res.json())\n.then(data => {\nreturn { ...data, processed: true };\n})\n.catch(err => {\nconsole.error(err);\nreturn { error: true, processed: false };\n});\n}\nfunction configureApp({ host = 'localhost', port = 3000, db: { url: dbUrl = 'sqlite://' } = {} } = {}) {\nreturn { host, port, dbUrl };\n}\nconst fs = require('fs');\nconst _privateState = new WeakMap();\nfunction setPrivate(obj, data) {\n_privateState.set(obj, data);\n}\nasync function loadPlugin(name) {\nconst mod = await import(`./${name}.js`);\nreturn mod;\n}\nimport fs from 'fs';\nimport path from 'path';\nimport url from 'url';\nexport class ExtraService { constructor() { this.ready = true; } }\nclass HelperComponent { render() { return null; } }\nexport default class WidgetFactory { create() { return {}; } }\nconst BoundComponent = React.memo(() => null);\nconst ForwardedWidget = React.forwardRef((_, ref) => ({ ref }));\nconst LazyWidget = React.lazy(() => import('./Widget'));\nconst MemoPanel = memo(() => null);\nconst API_TOKEN = 'tok';\nconst CACHE_SIZE = 128;\nconst RETRY_LIMIT = 5;\nconst pathMod = require('path');\nconst cryptoMod = require('crypto');\nconst utilMod = require('util');\nconst osMod = require('os');\nfunction reqCoverJs1(value) { return value + 1; }\nfunction reqCoverJs2(value) { return value + 2; }\nfunction reqCoverJs3(value) { return value + 3; }\nfunction reqCoverJs4(value) { return value + 4; }\nfunction reqCoverJs5(value) { return value + 5; }\n```\n\n@@@ src/fixture_kotlin.kt | kotlin\n> Lines: 11-449\n```\nimport kotlin.collections.List\nimport kotlinx.coroutines.flow.Flow\nimport kotlinx.coroutines.flow.flow\n@Deprecated(\"Use UserV2 instead\", replaceWith = ReplaceWith(\"UserV2\"))\ndata class User(val name: String, val age: Int = 0)\nsealed class Result<out T> {\ndata class Success<T>(val value: T) : Result<T>()\ndata class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\nobject Loading : Result<Nothing>()\nfun <R> map(transform: (T) -> R): Result<R> = when (this) {\nis Success -> Success(transform(value))\nis Error -> Error(message, cause)\nis Loading -> Loading\n}\n}\ninterface Repository<T> {\nfun findById(id: Int): T?\nfun save(entity: T): Boolean\nfun findAll(): Flow<T>\n}\nsealed interface Identifiable {\nval id: Int\n}\nenum class Color(val hex: String) {\nRED(\"#FF0000\"),\nGREEN(\"#00FF00\"),\nBLUE(\"#0000FF\");\ncompanion object {\nfun fromHex(hex: String): Color? = values().find { it.hex == hex }\n}\n}\ndata class Entity(\noverride val id: Int,\nval name: String,\nval status: String = \"active\",\n) : Identifiable\n@JvmInline\nvalue class EmailAddress(val value: String) {\ninit {\nrequire(value.contains('@')) { \"Invalid email: $value\" }\n}\nval domain: String get() = value.substringAfter('@')\n}\nfun greet(name: String): String {\nreturn \"Hello $name\"\n}\nsuspend fun fetchData(): String {\nreturn \"data\"\n}\nfun processItems(items: List<String>, transform: (String) -> String): List<String> {\nreturn items.map(transform)\n}\nfun String.wordCount(): Int {\nreturn this.trim().split(\"\\\\s+\".toRegex()).size\n}\nval String.lastChar: Char?\nget() = if (this.isEmpty()) null else this[this.length - 1]\ninline fun <reified T> filterByType(items: List<Any>): List<T> {\nreturn items.filterIsInstance<T>()\n}\ndata class Vector2(val x: Double, val y: Double) {\noperator fun plus(other: Vector2) = Vector2(x + other.x, y + other.y)\noperator fun unaryMinus() = Vector2(-x, -y)\noperator fun times(other: Vector2) = x * other.x + y * other.y\n}\nval PI = 3.14159265\nvar counter = 0\nobject Singleton {\nprivate val config = mutableMapOf<String, Any>()\nfun set(key: String, value: Any) {\nconfig[key] = value\n}\n@Suppress(\"UNCHECKED_CAST\")\nfun <T> get(key: String): T? = config[key] as? T\n}\ncompanion object Factory {\n}\nclass DelegatingList<T>(private val inner: MutableList<T>) : List<T> by inner {\nvar accessCount = 0\nprivate set\noverride val size: Int\nget() {\naccessCount++\nreturn inner.size\n}\n}\nclass Service {\nlateinit var dependency: Repository<Entity>\nval resource: String by lazy {\n\"expensive_resource\"\n}\nfun isReady(): Boolean = ::dependency.isInitialized\n}\nclass HtmlBuilder {\nprivate val elements = mutableListOf<String>()\nfun div(block: HtmlBuilder.() -> Unit) {\nval inner = HtmlBuilder()\ninner.block()\nelements.add(\"<div>${inner.build()}</div>\")\n}\nfun text(text: String) {\nelements.add(text)\n}\nfun build(): String = elements.joinToString(\"\")\n}\nfun html(block: HtmlBuilder.() -> Unit): String {\nval builder = HtmlBuilder()\nbuilder.block()\nreturn builder.build()\n}\nimport kotlin.math.max\nimport kotlin.math.min\ninterface Logger\ninterface Parser\ninterface Emitter\ninterface Formatter\nenum class ModeKt { FAST, SAFE }\nenum class PhaseKt { INIT, RUN }\nenum class StatusKt { READY, WAITING }\nenum class SignalKt { ON, OFF }\n@Synchronized\n@PublishedApi\nobject CacheStore\nvar retries = 0\nvar attempts = 0\nvar state = \"idle\"\nfun reqCoverKotlin1(value: Int): Int = value + 1\nfun reqCoverKotlin2(value: Int): Int = value + 2\nfun reqCoverKotlin3(value: Int): Int = value + 3\nfun reqCoverKotlin4(value: Int): Int = value + 4\nfun reqCoverKotlin5(value: Int): Int = value + 5\n```\n\n@@@ src/fixture_lua.lua | lua\n> Lines: 14-274\n```\nfunction globalFunc(x)\nreturn x + 1\nend\nlocal function localFunc(y)\nif type(y) ~= \"number\" then\nerror(\"expected number, got \" .. type(y))\nend\nreturn y * 2\nend\nlocal function sumAll(...)\nlocal total = 0\nlocal args = {...}\nfor _, v in ipairs(args) do\ntotal = total + v\nend\nreturn total\nend\nlocal myVar = 42\nlocal config = {\ndebug = false,\nmaxRetries = 3,\ntimeout = 30.0,\n}\nlocal handler = function(event)\nif event.type == \"click\" then\nprint(\"clicked at \" .. event.x .. \",\" .. event.y)\nelse\nprint(\"event: \" .. event.type)\nend\nend\nlocal MyModule = {}\nMyModule.__index = MyModule\nfunction MyModule.new(name)\nlocal self = setmetatable({}, MyModule)\nself.name = name\nself._items = {}\nreturn self\nend\nMyModule.method = function(self)\nreturn self.name\nend\nfunction MyModule:addItem(item)\ntable.insert(self._items, item)\nend\nfunction MyModule:count()\nreturn #self._items\nend\nlocal Animal = {}\nAnimal.__index = Animal\nfunction Animal.new(species)\nlocal self = setmetatable({}, Animal)\nself.species = species\nreturn self\nend\nfunction Animal:speak()\nreturn self.species .. \" says ...\"\nend\nlocal Dog = setmetatable({}, { __index = Animal })\nDog.__index = Dog\nfunction Dog.new(name)\nlocal self = Animal.new(\"Dog\")\nsetmetatable(self, Dog)\nself.dogName = name\nreturn self\nend\nfunction Dog:speak()\nreturn self.dogName .. \" says Woof!\"\nend\nlocal function makeCounter(step)\nlocal count = 0\nreturn function()\ncount = count + step\nreturn count\nend\nend\nlocal function fibonacci(limit)\nreturn coroutine.wrap(function()\nlocal a, b = 0, 1\nfor _ = 1, limit do\ncoroutine.yield(a)\na, b = b, a + b\nend\nend)\nend\nlocal function safeCall(fn, ...)\nlocal ok, result = pcall(fn, ...)\nif not ok then\nprint(\"Error: \" .. tostring(result))\nreturn false, nil\nend\nreturn true, result\nend\nlocal mixedTable = {\n\"first\",\n\"second\",\nname = \"test\",\ncount = 42,\n[math.pi] = \"pi\",\nnested = {\nx = 1,\ny = 2,\n},\n}\nlocal function range(from, to)\nlocal i = from - 1\nreturn function()\ni = i + 1\nif i <= to then\nreturn i\nend\nend\nend\nfunction req_cover_lua_1(value)\nreturn value + 1\nend\nfunction req_cover_lua_2(value)\nreturn value + 2\nend\nfunction req_cover_lua_3(value)\nreturn value + 3\nend\nfunction req_cover_lua_4(value)\nreturn value + 4\nend\nfunction req_cover_lua_5(value)\nreturn value + 5\nend\n```\n\n@@@ src/fixture_perl.pl | perl\n> Lines: 1-308\n```\n#!/usr/bin/perl\npackage MyPackage;\nuse strict;\nuse warnings;\nuse Carp qw(croak confess);\nrequire Exporter;\nuse constant MAX_SIZE => 100;\nuse constant {\nMIN_SIZE => 1,\nDEFAULT_NAME => 'unnamed',\n};\nour $VERSION = '1.0.0';\nour @EXPORT = qw(greet process);\nour @EXPORT_OK = qw(helper format_output);\nsub new {\nmy ($class, %args) = @_;\ncroak \"name is required\" unless $args{name};\nmy $self = bless {\nname  => $args{name},\nage   => $args{age} || 0,\n_items => [],\n_cache => {},\n}, $class;\nreturn $self;\n}\nsub name {\nmy ($self, $val) = @_;\nif (defined $val) {\n$self->{name} = $val;\nreturn $self;\n}\nreturn $self->{name};\n}\nsub is_valid {\nmy ($self) = @_;\nreturn defined($self->{name}) && length($self->{name}) > 0 ? 1 : 0;\n}\nsub greet {\nmy ($name) = @_;\nunless (defined $name) {\nwarn \"greet called without name\";\nreturn;\n}\nprint \"Hello $name\\n\";\n}\nsub process {\nreturn 1;\n}\nsub format_output {\nmy (@items) = @_;\nif (wantarray()) {\nreturn map { uc($_) } @items;\n} else {\nreturn scalar @items;\n}\n}\nsub helper {\nreturn \"ok\";\n}\nsub extract_emails {\nmy ($text) = @_;\nmy @emails;\nwhile ($text =~ /\\b([\\w.+-]+@[\\w-]+\\.[\\w.]+)\\b/g) {\npush @emails, $1;\n}\nreturn @emails;\n}\nsub replace_all {\nmy ($text, $pattern, $replacement) = @_;\n$text =~ s/$pattern/$replacement/g;\nreturn $text;\n}\nsub make_multiplier {\nmy ($factor) = @_;\nreturn sub {\nmy ($x) = @_;\nreturn $x * $factor;\n};\n}\nmy %dispatch = (\nadd    => sub { $_[0] + $_[1] },\nsub    => sub { $_[0] - $_[1] },\nmul    => sub { $_[0] * $_[1] },\ndiv    => sub {\ncroak \"Division by zero\" if $_[1] == 0;\nreturn $_[0] / $_[1];\n},\n);\nsub dispatch {\nmy ($op, $a, $b) = @_;\nmy $handler = $dispatch{$op}\nor croak \"Unknown operation: $op\";\nreturn $handler->($a, $b);\n}\nsub generate_template {\nmy ($name) = @_;\nreturn <<END_TEMPLATE;\nDear $name,\nThis is a generated template.\nVersion: $VERSION\nMax size: @{[ MAX_SIZE ]}\nRegards,\nThe System\nEND_TEMPLATE\n}\nsub AUTOLOAD {\nmy ($self, @args) = @_;\nour $AUTOLOAD;\nmy $method = $AUTOLOAD;\n$method =~ s/.*:://;\nreturn if $method eq 'DESTROY';\nif ($method =~ /^get_(\\w+)$/) {\nmy $attr = $1;\nreturn $self->{$attr};\n}\ncroak \"Undefined method: $method\";\n}\nsub safe_execute {\nmy ($code) = @_;\nmy $result = eval {\n$code->();\n};\nif ($@) {\nwarn \"Caught error: $@\";\nreturn undef;\n}\nreturn $result;\n}\n1;\npackage Extra::One;\npackage Extra::Two;\npackage Extra::Three;\npackage Extra::Four;\nuse constant RETRY_LIMIT => 5;\nuse constant API_HOST => 'localhost';\nuse constant FEATURE_FLAG => 1;\nuse constant CACHE_SIZE => 256;\nuse constant DEFAULT_USER => 'guest';\nuse lib 'lib';\nsub req_cover_perl_1 {\nmy ($value) = @_;\nreturn $value + 1;\n}\nsub req_cover_perl_2 {\nmy ($value) = @_;\nreturn $value + 2;\n}\nsub req_cover_perl_3 {\nmy ($value) = @_;\nreturn $value + 3;\n}\nsub req_cover_perl_4 {\nmy ($value) = @_;\nreturn $value + 4;\n}\nsub req_cover_perl_5 {\nmy ($value) = @_;\nreturn $value + 5;\n}\n```\n\n@@@ src/fixture_php.php | php\n> Lines: 1-431\n```\n<?php\nnamespace App\\Models;\nuse App\\Contracts\\Repository;\nuse App\\Events\\{ModelCreated, ModelDeleted};\nuse Psr\\Log\\LoggerInterface;\nrequire_once 'config.php';\nconst VERSION = \"1.0\";\nconst MAX_PER_PAGE = 50;\nenum Status: string {\ncase Draft = 'draft';\ncase Published = 'published';\ncase Archived = 'archived';\npublic function isActive(): bool {\nreturn $this === self::Published;\n}\npublic function label(): string {\nreturn match($this) {\nself::Draft => 'Draft',\nself::Published => 'Published',\nself::Archived => 'Archived',\n};\n}\n}\nabstract class BaseModel {\npublic function __construct(\npublic readonly int $id,\npublic readonly \\DateTimeImmutable $createdAt = new \\DateTimeImmutable(),\n) {}\npublic function save(): bool {\nif (!$this->validate()) {\nreturn false;\n}\nreturn true;\n}\nabstract protected function validate(): bool;\nprivate static function validateConstraints(): bool {\nreturn true;\n}\nabstract public function toArray(): array;\n}\nfinal class User extends BaseModel {\nprivate string $name;\nprivate ?string $email;\npublic function __construct(\nint $id,\nstring $name,\n?string $email = null,\n) {\nparent::__construct($id);\n$this->name = $name;\n$this->email = $email;\n}\npublic function getName(): string {\nreturn $this->name;\n}\npublic function getIdentifier(): string|int {\nreturn $this->email ?? $this->id;\n}\nprotected function validate(): bool {\nreturn strlen($this->name) > 0;\n}\npublic function toArray(): array {\nreturn [\n'id' => $this->id,\n'name' => $this->name,\n'email' => $this->email,\n];\n}\n}\ninterface Repo {\npublic function findAll(): iterable;\npublic function findById(int $id): ?BaseModel;\npublic function count(array $criteria = []): int;\n}\ntrait Cacheable {\nprotected int $cacheTtl = 3600;\npublic function cache(): bool {\nreturn true;\n}\npublic function invalidateCache(): void {\n}\nabstract public function cacheKey(): string;\n}\ntrait SoftDeletable {\nprotected ?\\DateTimeImmutable $deletedAt = null;\npublic function softDelete(): void {\n$this->deletedAt = new \\DateTimeImmutable();\n}\npublic function isDeleted(): bool {\nreturn $this->deletedAt !== null;\n}\n}\nfinal class CachedUser extends User {\nuse Cacheable;\nuse SoftDeletable;\npublic function cacheKey(): string {\nreturn \"user:{$this->id}\";\n}\n}\n#[\\Attribute(\\Attribute::TARGET_METHOD | \\Attribute::IS_REPEATABLE)]\nclass Route {\npublic function __construct(\npublic readonly string $path,\npublic readonly string $method = 'GET',\n) {}\n}\nfunction helper(): bool {\nreturn true;\n}\nfunction processData(mixed $data): string {\nreturn match(true) {\nis_string($data) => \"string: \" . strlen($data),\nis_int($data) => \"int: $data\",\nis_array($data) => \"array: \" . count($data),\n$data instanceof BaseModel => \"model: \" . $data->id,\ndefault => \"unknown\",\n};\n}\nfunction applyTransform(array $items, callable $fn): array {\nreturn array_map(fn(int $x): int => $fn($x), $items);\n}\nfunction createMultiplier(int $factor): \\Closure {\nreturn fn(int $x): int => $x * $factor;\n}\nfunction readFileContent(string $path): string|false {\nif (!file_exists($path)) {\nreturn false;\n}\nreturn file_get_contents($path);\n}\nnamespace App\\Services;\nnamespace App\\Http;\nnamespace App\\Domain;\nnamespace App\\Support;\ninterface ServiceContract {}\ninterface CacheContract {}\ninterface LoggerContract {}\ninterface EventContract {}\ntrait HandlesEvents {}\ntrait TracksChanges {}\ntrait AuthorizesRequests {}\nconst API_LIMIT = 50;\nconst DEFAULT_PAGE = 1;\nconst TIMEOUT = 30;\nfinal class ApiClient {}\nfunction req_cover_php_1(int $value): int { return $value + 1; }\nfunction req_cover_php_2(int $value): int { return $value + 2; }\nfunction req_cover_php_3(int $value): int { return $value + 3; }\nfunction req_cover_php_4(int $value): int { return $value + 4; }\nfunction req_cover_php_5(int $value): int { return $value + 5; }\n```\n\n@@@ src/fixture_python.py | python\n> Lines: 1-500\n```\n#!/usr/bin/env python3\nimport asyncio\nimport os\nimport sys\nfrom pathlib import Path\nfrom typing import (\n    Optional, List, Dict, Union, Protocol,\n    TypeVar, Generic, Iterator, AsyncIterator\n)\nfrom dataclasses import dataclass, field\nfrom abc import ABC, abstractmethod\nfrom contextlib import contextmanager\nMAX_RETRIES = 3\nDEFAULT_TIMEOUT = 30.0\n_INTERNAL_CACHE: Dict[str, int] = {}\nT = TypeVar(\"T\")\n@dataclass(slots=True)\nclass Config:\n    name: str\n    values: Dict[str, str] = field(default_factory=dict)\n    debug: bool = False\n    def get(self, key: str, default: str = \"\") -> str:\n        if key in self.values:\n            return self.values[key]\n        return default\n    def __post_init__(self) -> None:\n        if not self.name.strip():\n            raise ValueError(\"Config name cannot be empty\")\nclass MyClass:\n    class InnerHelper:\n        def __init__(self, tag: str):\n            self.tag = tag\n        def describe(self) -> str:\n            return f\"Helper({self.tag})\"\n    def __init__(self, name: str, retries: int = MAX_RETRIES):\n        self._name = name\n        self._retries = retries\n        self._call_count = 0\n    @property\n    def name(self) -> str:\n        return self._name\n    @name.setter\n    def name(self, value: str) -> None:\n        if not value:\n            raise ValueError(\"Name cannot be empty\")\n        self._name = value\n    @staticmethod\n    def create_default() -> \"MyClass\":\n        return MyClass(\"default\")\n    @classmethod\n    def from_dict(cls, data: dict) -> \"MyClass\":\n        return cls(\n            name=data[\"name\"],\n            retries=data.get(\"retries\", MAX_RETRIES),\n        )\n    def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]:\n        self._call_count += 1\n        for item in items:\n            if not item.strip():\n                continue\n            if verbose:\n                print(f\"Processing: {item}\")\n            return item if len(item) > 1 else item.upper()\n        return None\n    def compute(self, x: int, y: int) -> int:\n        return (x + y) if (x > 0 and y > 0) else abs(x - y)\nclass AbstractProcessor(ABC):\n    @abstractmethod\n    def execute(self, data: bytes) -> bool:\n        ...\n    @abstractmethod\n    async def execute_async(self, data: bytes) -> bool:\n        ...\nclass ConcreteProcessor(AbstractProcessor):\n    def execute(self, data: bytes) -> bool:\n        try:\n            text = data.decode(\"utf-8\")\n            return bool(text.strip())\n        except UnicodeDecodeError:\n            return False\n        finally:\n            pass\n    async def execute_async(self, data: bytes) -> bool:\n        return self.execute(data)\nclass GenericContainer(Generic[T]):\n    def __init__(self) -> None:\n        self._items: List[T] = []\n    def add(self, item: T) -> None:\n        self._items.append(item)\n    def __iter__(self) -> Iterator[T]:\n        yield from self._items\n    def find(self, predicate) -> Optional[T]:\n        for item in self._items:\n            if predicate(item):\n                return item\n        return None\nclass Renderable(Protocol):\n    def render(self) -> str:\n        ...\n@property\ndef regular_function(x: int) -> int:\n    return x\ndef function_with_walrus(data: List[int]) -> Optional[int]:\n    if (n := next((x for x in data if x > 10), None)) is not None:\n        return n\n    return None\ndef multi_return_paths(value: int) -> Union[str, int, None]:\n    match value:\n        case 0:\n            return \"zero\"\n        case n if n < 0:\n            return abs(n)\n        case n if n > 100:\n            return None\n        case _:\n            return str(value)\ndef generator_function(limit: int) -> Iterator[int]:\n    for i in range(limit):\n        yield i * i\nasync def async_generator(items: List[str]) -> AsyncIterator[str]:\n    for item in items:\n        if item.strip():\n            yield item.upper()\n@contextmanager\ndef managed_resource(path: str):\n    f = open(path, \"r\")\n    try:\n        yield f\n    finally:\n        f.close()\ndef closure_factory(multiplier: int):\n    def inner(x: int) -> int:\n        return x * multiplier\n    return inner\ndef uses_unpacking(*args: int, **kwargs: str) -> Dict[str, Union[int, str]]:\n    result: Dict[str, Union[int, str]] = {}\n    for i, val in enumerate(args):\n        result[f\"arg_{i}\"] = val\n    result.update(kwargs)\n    return result\ntransform = lambda x: x * 2 + 1\nEVEN_SQUARES = [x ** 2 for x in range(20) if x % 2 == 0]\nasync def async_function():\n    await asyncio.sleep(0)\ndef deeply_nested_logic(matrix: List[List[int]]) -> int:\n    total = 0\n    for row in matrix:\n        for val in row:\n            if val > 0:\n                if val % 2 == 0:\n                    total += val\n                else:\n                    continue\n            else:\n                pass\n    return total\ndef exception_handling_example(path: str) -> Optional[str]:\n    try:\n        with open(path, \"r\") as f:\n            content = f.read()\n        if not content:\n            raise ValueError(\"Empty file\")\n        return content\n    except FileNotFoundError:\n        return None\n    except (PermissionError, OSError) as e:\n        sys.exit(1)\n    except Exception:\n        raise\n    finally:\n        pass\nMAX_BATCH = 64\nCACHE_LIMIT = 128\nMAX_USERS = 500\ndef req_cover_py_1(value: int) -> int:\n    return value + 1\ndef req_cover_py_2(value: int) -> int:\n    return value + 2\ndef req_cover_py_3(value: int) -> int:\n    return value + 3\ndef req_cover_py_4(value: int) -> int:\n    return value + 4\ndef req_cover_py_5(value: int) -> int:\n    return value + 5\n```\n\n@@@ src/fixture_ruby.rb | ruby\n> Lines: 10-343\n```\nrequire 'json'\nrequire 'set'\nrequire_relative 'helper'\nMAX_RETRIES = 42\nDEFAULT_ENCODING = 'utf-8'.freeze\nattr_accessor :name, :age\nmodule Loggable\ndef log(message)\nputs \"[#{self.class.name}] #{message}\"\nend\ndef log_error(error)\nputs \"[ERROR] #{error.message}\"\nputs error.backtrace.first(5).join(\"\\n\") if error.backtrace\nend\nend\nclass MyClass\ninclude Loggable\ninclude Comparable\nattr_accessor :name\nattr_reader :created_at\ndef initialize(name, **options)\n@name = name\n@options = options\n@created_at = Time.now\n@options[:retries] ||= MAX_RETRIES\nend\ndef self.create(attrs)\nnew(attrs[:name], **attrs.except(:name))\nend\ndef self.bulk_create(names)\nnames.map { |n| new(n) }\nend\ndef valid?\n!@name.nil? && !@name.empty?\nend\ndef matches?(pattern)\nreturn false if @name.nil?\npattern.match?(@name)\nend\ndef <=>(other)\n@name <=> other.name\nend\ndef +(other)\nself.class.new(\"#{@name}+#{other.name}\")\nend\ndef to_s\n\"MyClass(#{@name})\"\nend\ndef method_missing(method, *args, &block)\nif method.to_s.start_with?('find_by_')\nfield = method.to_s.sub('find_by_', '')\n\"Finding by #{field}: #{args.first}\"\nelse\nsuper\nend\nend\ndef respond_to_missing?(method, include_private = false)\nmethod.to_s.start_with?('find_by_') || super\nend\nprotected\ndef internal_config\n@options.dup\nend\nprivate\ndef validate!\nraise \"Invalid name\" unless valid?\nend\nend\nclass SpecialClass < MyClass\ndef initialize(name, priority: 0, **options)\nsuper(name, **options)\n@priority = priority\nend\ndef to_s\n\"SpecialClass(#{@name}, pri=#{@priority})\"\nend\nend\nmodule MyModule\ndef helper\ntrue\nend\ndef process_with_block(data)\nif block_given?\nyield(data)\nelse\ndata\nend\nend\ndef self.format_list(items)\nitems.map(&:to_s).join(', ')\nend\nend\nCoordinate = Struct.new(:x, :y) do\ndef distance_from_origin\nMath.sqrt(x**2 + y**2)\nend\nend\nclass DynamicModel\n%w[title body author].each do |field|\ndefine_method(field) do\ninstance_variable_get(\"@#{field}\")\nend\ndefine_method(\"#{field}=\") do |value|\ninstance_variable_set(\"@#{field}\", value)\nend\nend\nend\ndoubler = ->(x) { x * 2 }\ngreeting_proc = Proc.new { |name| \"Hello, #{name}!\" }\ndef with_retry(attempts: MAX_RETRIES)\ntries = 0\nbegin\ntries += 1\nyield\nrescue StandardError => e\nretry if tries < attempts\nraise \"Failed after #{attempts} attempts: #{e.message}\"\nensure\nputs \"Completed after #{tries} attempt(s)\"\nend\nend\nmodule StringExtensions\nrefine String do\ndef email?\nmatch?(/\\A[\\w+\\-.]+@[a-z\\d\\-]+(\\.[a-z\\d\\-]+)*\\.[a-z]+\\z/i)\nend\nend\nend\nclass ServiceObject; end\nclass ReportBuilder; end\nmodule Metrics; end\nmodule Extras; end\nMAX_LIMIT = 100\nAPI_VERSION = \"v2\"\nCACHE_SIZE = 1024\nattr_writer :token\nattr_reader :state\nrequire 'yaml'\nrequire 'logger'\ndef req_cover_ruby_1(value)\nvalue + 1\nend\ndef req_cover_ruby_2(value)\nvalue + 2\nend\ndef req_cover_ruby_3(value)\nvalue + 3\nend\ndef req_cover_ruby_4(value)\nvalue + 4\nend\ndef req_cover_ruby_5(value)\nvalue + 5\nend\n```\n\n@@@ src/fixture_rust.rs | rust\n> Lines: 9-378\n```\nuse std::io;\nuse std::collections::HashMap;\nuse std::fmt::{self, Display, Formatter};\nuse std::sync::{Arc, Mutex};\n#[derive(Debug, Clone, PartialEq)]\npub struct MyStruct {\nfield: i32,\n}\n#[derive(Debug)]\npub struct BorrowedData<'a> {\ncontent: &'a str,\ntag: u64,\n}\npub struct TypedMap<K: std::hash::Hash + Eq, V: Clone> {\ninner: HashMap<K, V>,\n}\npub enum MyEnum {\nA,\nB(String),\nC { x: i32, y: i32 },\n}\npub trait MyTrait {\nfn do_work(&self);\nfn do_work_with_ctx(&self, ctx: &str) -> bool {\nprintln!(\"ctx: {}\", ctx);\nself.do_work();\ntrue\n}\n}\npub trait Parser<'a> {\ntype Output;\nfn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>;\n}\nimpl MyStruct {\nfn new() -> Self {\nSelf { field: 0 }\n}\npub fn with_value(val: i32) -> Self {\nSelf { field: val }\n}\npub fn value(&self) -> i32 {\nself.field\n}\npub fn try_update(&mut self, new_val: i32) -> Option<i32> {\nif new_val == self.field {\nreturn None;\n}\nlet old = self.field;\nself.field = new_val;\nSome(old)\n}\n}\nimpl MyTrait for MyStruct {\nfn do_work(&self) {\nprintln!(\"{:?}\", self);\n}\n}\nimpl Display for MyStruct {\nfn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\nwrite!(f, \"MyStruct({})\", self.field)\n}\n}\nimpl<K, V> TypedMap<K, V>\nwhere\nK: std::hash::Hash + Eq + Display,\nV: Clone + Default,\n{\npub fn insert(&mut self, key: K, value: V) -> Option<V> {\nself.inner.insert(key, value)\n}\npub fn get_or_default(&self, key: &K) -> V {\nmatch self.inner.get(key) {\nSome(v) => v.clone(),\nNone => V::default(),\n}\n}\n}\npub mod my_module;\npub(crate) mod internal {\npub(crate) static COUNTER: std::sync::atomic::AtomicUsize =\nstd::sync::atomic::AtomicUsize::new(0);\n}\nmacro_rules! hashmap {\n($($key:expr => $val:expr),* $(,)?) => {{\nlet mut map = HashMap::new();\n$(map.insert($key, $val);)*\nmap\n}};\n}\nmacro_rules! my_macro {\n() => {};\n($x:expr) => { println!(\"{}\", $x) };\n($x:expr, $($rest:expr),+) => {\nprint!(\"{}, \", $x);\nmy_macro!($($rest),+);\n};\n}\nconst MY_CONST: i32 = 42;\nstatic MY_STATIC: i32 = 0;\nstatic CONFIG: std::sync::LazyLock<HashMap<String, String>> =\nstd::sync::LazyLock::new(|| HashMap::new());\npub type IoResult<T> = Result<T, io::Error>;\npub type MyAlias = i32;\npub fn my_function(input: Option<&str>) -> String {\nlet text = match input {\nSome(s) if !s.is_empty() => s,\nSome(_) => return String::from(\"empty\"),\nNone => return String::from(\"none\"),\n};\ntext.to_uppercase()\n}\npub async fn async_function() -> String {\nString::from(\"hello async\")\n}\npub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>\nwhere\nF: Fn(&i32) -> bool,\n{\nitems.iter().copied().filter(|x| predicate(x)).collect()\n}\npub fn create_worker(use_struct: bool) -> Box<dyn MyTrait> {\nif use_struct {\nBox::new(MyStruct::new())\n} else {\npanic!(\"No alternative implementation available\");\n}\n}\npub unsafe fn read_raw(ptr: *const i32) -> i32 {\n*ptr\n}\npub extern \"C\" fn ffi_double(x: i32) -> i32 {\nx * 2\n}\npub fn describe_enum(val: &MyEnum) -> String {\nmatch val {\nMyEnum::A => String::from(\"unit\"),\nMyEnum::B(s) => format!(\"string: {}\", s),\nMyEnum::C { x, y } => {\nlet mag = ((x * x + y * y) as f64).sqrt();\nformat!(\"point({}, {}) mag={:.2}\", x, y, mag)\n}\n}\n}\nuse std::time::Duration;\npub mod ext_tools { pub fn id() -> i32 { 1 } }\nmod ext_local { pub fn ping() -> i32 { 2 } }\npub mod ext_api { pub fn pong() -> i32 { 3 } }\n#[inline]\n#[allow(dead_code)]\n#[cfg(test)]\npub enum Status { Ready, Busy }\npub enum Mode { Alpha, Beta }\npub enum Signal { On, Off }\npub enum ErrorKind { Io, Parse }\npub struct ExtraNode { pub id: i32 }\nstruct InnerNode { id: i32 }\npub trait Inspectable { fn inspect(&self) -> i32; }\ntrait Named { fn name(&self) -> &'static str; }\npub trait Executable { fn exec(&self) -> i32; }\nimpl Inspectable for ExtraNode { fn inspect(&self) -> i32 { self.id } }\nimpl Named for InnerNode { fn name(&self) -> &'static str { \"inner\" } }\nimpl Executable for MyEnum { fn exec(&self) -> i32 { 1 } }\nmacro_rules! ext_macro { () => { 42 } }\nmacro_rules! trace_macro { ($v:expr) => { $v }; }\nmacro_rules! build_pair { ($a:expr,$b:expr) => { ($a,$b) }; }\npub const LIMIT: usize = 8;\npub type ItemId = u64;\ntype AliasValue = i32;\nfn req_cover_rust_1(value: i32) -> i32 { value + 1 }\nfn req_cover_rust_2(value: i32) -> i32 { value + 2 }\nfn req_cover_rust_3(value: i32) -> i32 { value + 3 }\nfn req_cover_rust_4(value: i32) -> i32 { value + 4 }\nfn req_cover_rust_5(value: i32) -> i32 { value + 5 }\n```\n\n@@@ src/fixture_scala.scala | scala\n> Lines: 11-397\n```\nimport scala.collection.mutable\nimport scala.concurrent.{Future, ExecutionContext}\nimport scala.util.{Try, Success, Failure}\ncase class Person(name: String, age: Int) {\ndef isAdult: Boolean = age >= 18\ndef greet: String = s\"Hi, I'm $name, age $age\"\n}\nsealed trait Shape {\ndef area: Double\n}\ncase class Circle(radius: Double) extends Shape {\noverride def area: Double = math.Pi * radius * radius\n}\ncase class Rectangle(width: Double, height: Double) extends Shape {\noverride def area: Double = width * height\n}\nabstract class Animal {\ndef sound: String\ndef describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n}\ntrait Drawable {\ndef draw(): Unit\n}\ntrait Logging { self: Drawable =>\ndef logAndDraw(): Unit = {\nprintln(\"About to draw\")\ndraw()\n}\n}\ntrait Serializable {\ndef serialize: Array[Byte]\n}\nobject Main {\ndef main(args: Array[String]): Unit = {\nval people = List(Person(\"Alice\", 30), Person(\"Bob\", 17))\nval adults = people.filter(_.isAdult)\nadults.foreach(p => println(p.greet))\n}\noverride def toString: String = \"Main\"\nval pi = 3.14159265\nvar counter = 0\ntype StringList = List[String]\ntype Transformer[A] = A => A\ndef describeShape(shape: Shape): String = shape match {\ncase Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\ncase Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n}\ndef classify(x: Int): String = x match {\ncase 0 => \"zero\"\ncase n if n < 0 => \"negative\"\ncase n if n > 100 => \"large\"\ncase _ => \"positive\"\n}\n}\nclass Config private (val entries: Map[String, String]) {\ndef get(key: String): Option[String] = entries.get(key)\n}\nobject Config {\ndef apply(entries: (String, String)*): Config = new Config(entries.toMap)\ndef empty: Config = new Config(Map.empty)\n}\nclass Container[+A](val value: A) {\ndef map[B](f: A => B): Container[B] = new Container(f(value))\ndef flatMap[B](f: A => Container[B]): Container[B] = f(value)\n}\nimplicit class RichInt(val n: Int) extends AnyVal {\ndef isEven: Boolean = n % 2 == 0\ndef times(s: String): String = s * n\n}\nobject ForCompExample {\ndef findPairs(range: Int, target: Int): List[(Int, Int)] = {\nfor {\nx <- (1 to range).toList\ny <- (x to range).toList\nif x + y == target\n} yield (x, y)\n}\n}\nobject FuncUtils {\ndef add(a: Int)(b: Int): Int = a + b\ndef twice[A](f: A => A)(x: A): A = f(f(x))\ndef compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n}\nimport scala.util.Random\nimport scala.concurrent.duration._\ntrait Runner\ntrait Parser\nobject Metrics\nval MaxUsers = 100\nval RetryLimit = 3\ntype UserKey = String\ntype ErrorCode = Int\ntype Mapper = String => String\nvar attempts = 0\nvar cursor = 1\nvar stage = \"init\"\nvar status = \"ready\"\nobject ReqCoverScala {\ndef reqCoverScala1(value: Int): Int = value + 1\ndef reqCoverScala2(value: Int): Int = value + 2\ndef reqCoverScala3(value: Int): Int = value + 3\ndef reqCoverScala4(value: Int): Int = value + 4\ndef reqCoverScala5(value: Int): Int = value + 5\n}\n```\n\n@@@ src/fixture_shell.sh | shell\n> Lines: 1-274\n```\n#!/bin/bash\nMY_VAR=\"hello\"\nexport PATH_EXT=\"/usr/local/bin\"\nreadonly MAX_COUNT=10\ndeclare -r BUILD_VERSION=\"1.0.0\"\nDEBUG_MODE=0\ndeclare -a LANGUAGES=(\"python\" \"rust\" \"go\" \"java\" \"typescript\")\ndeclare -A EXT_MAP=(\n[py]=\"python\"\n[rs]=\"rust\"\n[go]=\"go\"\n[java]=\"java\"\n[ts]=\"typescript\"\n)\nfunction greet() {\nlocal name=\"${1:?Name required}\"\nif [[ -z \"$name\" ]]; then\necho \"Error: empty name\" >&2\nreturn 1\nfi\necho \"Hello ${name}!\"\n}\ncleanup() {\nlocal tmp_dir=\"${TMPDIR:-<PROJECT_PARENT>}/myapp_$$\"\nif [[ -d \"$tmp_dir\" ]]; then\nrm -rf \"$tmp_dir\"\nfi\necho \"Cleanup complete\"\n}\nparse_args() {\nlocal opt\nwhile getopts \"vdhf:o:\" opt; do\ncase \"$opt\" in\nv)\nVERBOSE=1\n;;\nd)\nDEBUG_MODE=1\n;;\nf)\nINPUT_FILE=\"$OPTARG\"\n;;\no)\nOUTPUT_FILE=\"$OPTARG\"\n;;\nh)\necho \"Usage: $0 [-v] [-d] [-f file] [-o output] [-h]\"\nreturn 0\n;;\n*)\necho \"Unknown option: $opt\" >&2\nreturn 1\n;;\nesac\ndone\nshift $((OPTIND - 1))\n}\nprocess_file() {\nlocal input=\"$1\"\nlocal output=\"${2:-/dev/stdout}\"\nif [[ ! -f \"$input\" ]]; then\necho \"Error: file not found: $input\" >&2\nreturn 1\nfi\nif [[ ! -r \"$input\" ]]; then\necho \"Error: file not readable: $input\" >&2\nreturn 1\nfi\nlocal line_count\nline_count=$(wc -l < \"$input\")\necho \"Processing $input ($line_count lines)\" >&2\nwhile IFS= read -r line; do\n[[ -z \"$line\" || \"$line\" =~ ^[[:space:]]*\necho \"$line\"\ndone < \"$input\" > \"$output\"\nreturn 0\n}\nretry_command() {\nlocal max_attempts=\"$1\"\nshift\nlocal attempt=1\nwhile (( attempt <= max_attempts )); do\nif \"$@\"; then\nreturn 0\nfi\necho \"Attempt $attempt/$max_attempts failed\" >&2\n(( attempt++ ))\nsleep $(( 2 ** (attempt - 1) ))\ndone\necho \"All $max_attempts attempts failed\" >&2\nreturn 1\n}\nlog_message() {\nlocal level=\"$1\"\nshift\nlocal timestamp\ntimestamp=$(date '+%Y-%m-%d %H:%M:%S')\necho \"[$timestamp] [$level] $*\" >&2\n}\nmake_temp() {\nlocal tmpfile\ntmpfile=$(mktemp \"${TMPDIR:-<PROJECT_PARENT>}/myapp_XXXXXX\")\necho \"$tmpfile\"\n}\ntrap cleanup EXIT\ntrap 'echo \"Interrupted\"; exit 130' INT TERM\ngenerate_config() {\ncat <<EOF\nversion=${BUILD_VERSION}\ndebug=${DEBUG_MODE}\nmax_count=${MAX_COUNT}\nEOF\n}\nfactorial() {\nlocal n=\"${1:-1}\"\nlocal result=1\nlocal i\nfor (( i = 2; i <= n; i++ )); do\n(( result *= i ))\ndone\necho \"$result\"\n}\nif [[ -f ./config.sh ]]; then\nsource ./config.sh\nfi\nsource ./env.sh\n. ./helpers.sh\nsource ./shared.sh\n. ./paths.sh\nsource ./runtime.sh\n. ./exports.sh\nsource ./network.sh\nreq_cover_shell_1() {\necho \"$(( $1 + 1 ))\"\n}\nreq_cover_shell_2() {\necho \"$(( $1 + 2 ))\"\n}\nreq_cover_shell_3() {\necho \"$(( $1 + 3 ))\"\n}\nreq_cover_shell_4() {\necho \"$(( $1 + 4 ))\"\n}\nreq_cover_shell_5() {\necho \"$(( $1 + 5 ))\"\n}\n```\n\n@@@ src/fixture_swift.swift | swift\n> Lines: 8-395\n```\nimport Foundation\nimport Combine\nclass Animal {\nvar species: String\nvar legs: Int = 4 {\nwillSet {\nprint(\"Legs changing from \\(legs) to \\(newValue)\")\n}\ndidSet {\nif legs < 0 { legs = 0 }\n}\n}\nvar description: String {\nreturn \"\\(species) with \\(legs) legs\"\n}\ninit(species: String) {\nself.species = species\n}\nfunc speak() {\nprint(\"...\")\n}\nclass func createDefault() -> Animal {\nreturn Animal(species: \"Unknown\")\n}\ndeinit {\nprint(\"\\(species) deallocated\")\n}\n}\nclass Dog: Animal {\nlet name: String\ninit(name: String) {\nself.name = name\nsuper.init(species: \"Dog\")\n}\noverride func speak() {\nprint(\"\\(name) says: Woof!\")\n}\n}\nstruct Point: Equatable {\nvar x: Double = 0.0\nvar y: Double = 0.0\nstatic func + (lhs: Point, rhs: Point) -> Point {\nreturn Point(x: lhs.x + rhs.x, y: lhs.y + rhs.y)\n}\nvar magnitude: Double {\nreturn (x * x + y * y).squareRoot()\n}\n}\nstruct Matrix {\nprivate var data: [[Double]]\nlet rows: Int\nlet cols: Int\ninit(rows: Int, cols: Int) {\nself.rows = rows\nself.cols = cols\ndata = Array(repeating: Array(repeating: 0.0, count: cols), count: rows)\n}\nsubscript(row: Int, col: Int) -> Double {\nget { return data[row][col] }\nset { data[row][col] = newValue }\n}\n}\nenum Direction: String, CaseIterable {\ncase up = \"UP\"\ncase down = \"DOWN\"\ncase left = \"LEFT\"\ncase right = \"RIGHT\"\nvar opposite: Direction {\nswitch self {\ncase .up: return .down\ncase .down: return .up\ncase .left: return .right\ncase .right: return .left\n}\n}\n}\nenum AppResult<T> {\ncase success(T)\ncase failure(Error)\nfunc map<U>(_ transform: (T) -> U) -> AppResult<U> {\nswitch self {\ncase .success(let value):\nreturn .success(transform(value))\ncase .failure(let error):\nreturn .failure(error)\n}\n}\n}\nprotocol Drawable {\nfunc draw() -> String\nvar renderPriority: Int { get }\n}\nprotocol Container {\nassociatedtype Item\nmutating func add(_ item: Item)\nvar count: Int { get }\n}\nextension Drawable {\nvar renderPriority: Int { return 0 }\nfunc debugDraw() -> String {\nreturn \"[\\(renderPriority)] \\(draw())\"\n}\n}\nextension Animal: Drawable {\nfunc draw() -> String {\nreturn description\n}\nfunc describe() -> String {\nreturn \"Animal: \\(species)\"\n}\n}\n@propertyWrapper\nstruct Clamped<Value: Comparable> {\nlet min: Value\nlet max: Value\nprivate var value: Value\nvar wrappedValue: Value {\nget { return value }\nset { value = Swift.min(Swift.max(newValue, min), max) }\n}\ninit(wrappedValue: Value, min: Value, max: Value) {\nself.min = min\nself.max = max\nself.value = Swift.min(Swift.max(wrappedValue, min), max)\n}\n}\nactor Counter {\nprivate var value: Int = 0\nfunc increment() -> Int {\nvalue += 1\nreturn value\n}\nfunc reset() {\nvalue = 0\n}\n}\npublic func greet(name: String) {\nprint(\"Hello \\(name)\")\n}\nfunc makeDrawable() -> some Drawable {\nreturn Animal(species: \"Cat\")\n}\nfunc contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable {\nreturn items.contains(target)\n}\nfunc deferred(_ action: @escaping () -> Void) -> () -> Void {\nreturn {\naction()\n}\n}\nlet MAX_SIZE = 1024\nprivate var counter = 0\nlet defaultConfig: [String: Any] = {\nvar config: [String: Any] = [:]\nconfig[\"debug\"] = false\nconfig[\"version\"] = \"1.0\"\nreturn config\n}()\nimport SwiftUI\nimport Combine\nimport Foundation\nimport Dispatch\nimport UIKit\nclass ServiceController {}\nfinal class CacheStore {}\nstruct Vector2 { let x: Int; let y: Int }\nstruct Limits { let max: Int }\nenum ModeSwift { case fast, safe }\nenum PhaseSwift { case initState, done }\nenum SignalSwift { case on, off }\nprotocol RunnerSwift { func run() }\nprotocol LoggerSwift { func log(_ msg: String) }\nprotocol ParserSwift { func parse(_ input: String) -> String }\nextension String { func trimmed2() -> String { self.trimmingCharacters(in: .whitespaces) } }\nextension Int { func doubled2() -> Int { self * 2 } }\nextension Array { var isNotEmpty: Bool { !self.isEmpty } }\nfunc reqCoverSwift1(_ value: Int) -> Int { value + 1 }\nfunc reqCoverSwift2(_ value: Int) -> Int { value + 2 }\nfunc reqCoverSwift3(_ value: Int) -> Int { value + 3 }\nfunc reqCoverSwift4(_ value: Int) -> Int { value + 4 }\nfunc reqCoverSwift5(_ value: Int) -> Int { value + 5 }\n```\n\n@@@ src/fixture_typescript.ts | typescript\n> Lines: 10-432\n```\nimport { Component } from 'react';\nimport type { ReactNode } from 'react';\ninterface User {\nname: string;\nage: number;\nemail?: string;\nreadonly id: string;\n}\ninterface Repository<T> {\nfindById(id: string): Promise<T | null>;\nsave(entity: T): Promise<T>;\ndelete(id: string): Promise<boolean>;\n}\ninterface Serializable {\ntoJSON(): string;\n}\ntype StringOrNumber = string | number;\ntype DeepReadonly<T> = {\nreadonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];\n};\ntype Unwrap<T> = T extends Array<infer U> ? U : T;\ntype PixelValue = `${number}px`;\ntype ApiResponse<T> =\n| { status: 'success'; data: T }\n| { status: 'error'; message: string }\n| { status: 'loading' };\ntype KeysOfType<T, V> = {\n[K in keyof T]: T[K] extends V ? K : never;\n}[keyof T];\nconst enum Direction {\nUp = 'UP',\nDown = 'DOWN',\nLeft = 'LEFT',\nRight = 'RIGHT',\n}\nenum Color {\nRed,\nBlue,\nGreen = 10,\n}\nenum HttpStatus {\nOK = '200',\nNotFound = '404',\nServerError = '500',\n}\nexport abstract class Base {\nabstract render(): void;\nexecute(): void {\nconsole.log('before render');\nthis.render();\nconsole.log('after render');\n}\n}\nclass Derived extends Base {\nvalue: number = 0;\nlabel?: string;\nrender(): void {\nconsole.log(this.value);\n}\n}\nclass TypedContainer<T extends Serializable> {\nprivate items: T[] = [];\nadd(item: T): void {\nthis.items.push(item);\n}\ntoJSON(): string {\nreturn `[${this.items.map(i => i.toJSON()).join(',')}]`;\n}\nfind(predicate: (item: T) => boolean): T | undefined {\nfor (const item of this.items) {\nif (predicate(item)) {\nreturn item;\n}\n}\nreturn undefined;\n}\n}\nclass UserEntity implements User, Serializable {\nreadonly id: string;\nname: string;\nage: number;\nconstructor(id: string, name: string, age: number) {\nthis.id = id;\nthis.name = name;\nthis.age = age;\n}\ntoJSON(): string {\nreturn JSON.stringify({ id: this.id, name: this.name, age: this.age });\n}\n}\nexport function greet(name: string): void {\nconsole.log(`Hello, ${name}`);\n}\nfunction parse(input: string): number;\nfunction parse(input: number): string;\nfunction parse(input: string | number): string | number {\nif (typeof input === 'string') {\nreturn parseInt(input, 10);\n}\nreturn input.toString();\n}\nconst add = (a: number): number => a + 1;\nconst transform = <T extends { toString(): string }>(value: T): string => {\nreturn value.toString();\n};\nasync function fetchEntity<T>(url: string): Promise<T> {\nconst response = await fetch(url);\nreturn response.json() as Promise<T>;\n}\nexport namespace MyNS {\nexport const x = 1;\nexport function double(val: number): number {\nreturn val * 2;\n}\n}\ndeclare module MyMod {\nexport const version: string;\n}\n@Component\nclass Decorated {\ntemplate: string = '<div></div>';\n}\nfunction isUser(value: unknown): value is User {\nif (typeof value !== 'object' || value === null) {\nreturn false;\n}\nconst obj = value as Record<string, unknown>;\nreturn typeof obj.name === 'string' && typeof obj.age === 'number';\n}\nconst config = {\nwidth: '100px' as PixelValue,\nheight: '200px' as PixelValue,\n} satisfies Record<string, PixelValue>;\nfunction makeOptional<T extends object>(obj: T): Partial<T> {\nreturn { ...obj };\n}\nimport { Injectable } from 'inversify';\nimport { Observable } from 'rxjs';\nimport { FC } from 'react';\n@injectable\n@sealed\n@track\n@memoized\ninterface CacheEntry { key: string; value: string }\nexport interface Runner { run(): Promise<void> }\nenum ModeTs { Fast, Safe }\nenum StatusTs { Ready, Busy }\nnamespace ExtNSOne { export const v = 1; }\nnamespace ExtNSTwo { export const v = 2; }\nnamespace ExtNSThree { export const v = 3; }\nnamespace ExtNSFour { export const v = 4; }\ndeclare module ExtOne { export const one: number; }\nmodule ExtTwo { export const two = 2; }\nmodule ExtThree { export const three = 3; }\nmodule ExtFour { export const four = 4; }\nfunction reqCoverTs1(value: number): number { return value + 1; }\nfunction reqCoverTs2(value: number): number { return value + 2; }\nfunction reqCoverTs3(value: number): number { return value + 3; }\nfunction reqCoverTs4(value: number): number { return value + 4; }\nfunction reqCoverTs5(value: number): number { return value + 5; }\n```\n\n@@@ src/fixture_zig.zig | zig\n> Lines: 7-293\n```\nconst std = @import(\"std\");\nconst mem = @import(\"std\").mem;\nconst Allocator = std.mem.Allocator;\npub fn main() void {\nstd.debug.print(\"Hello\\n\", .{});\n}\npub fn add(a: i32, b: i32) i32 {\nreturn a + b;\n}\npub fn safeDivide(numerator: i32, denominator: i32) !i32 {\nif (denominator == 0) {\nreturn error.DivisionByZero;\n}\nreturn @divTrunc(numerator, denominator);\n}\npub fn max(comptime T: type, a: T, b: T) T {\nreturn if (a > b) a else b;\n}\npub fn indexOf(comptime T: type, haystack: []const T, needle: T) ?usize {\nfor (haystack, 0..) |item, i| {\nif (item == needle) {\nreturn i;\n}\n}\nreturn null;\n}\npub fn comptimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8 {\nreturn a ++ b;\n}\npub fn createBuffer(allocator: Allocator) ![]u8 {\nconst buf = try allocator.alloc(u8, 1024);\nerrdefer allocator.free(buf);\n@memset(buf, 0);\nreturn buf;\n}\ninline fn fastSum(values: []const f32) f32 {\nvar total: f32 = 0.0;\nfor (values) |v| {\ntotal += v;\n}\nreturn total;\n}\nexport fn doubleValue(x: i32) i32 {\nreturn x * 2;\n}\nconst Point = struct {\nx: f64,\ny: f64,\npub fn distSquared(self: Point, other: Point) f64 {\nconst dx = self.x - other.x;\nconst dy = self.y - other.y;\nreturn dx * dx + dy * dy;\n}\npub fn origin() Point {\nreturn .{ .x = 0.0, .y = 0.0 };\n}\n};\nconst PackedFlags = packed struct {\nreadable: bool,\nwritable: bool,\nexecutable: bool,\nreserved: u5,\n};\nconst Config = struct {\nname: []const u8 = \"default\",\nmax_retries: u32 = 3,\ntimeout_ms: u64 = 5000,\ndebug: bool = false,\npub fn testing() Config {\nreturn .{ .debug = true, .name = \"test\" };\n}\n};\nconst Color = enum {\nred,\ngreen,\nblue,\npub fn toRgb(self: Color) u32 {\nreturn switch (self) {\n.red => 0xFF0000,\n.green => 0x00FF00,\n.blue => 0x0000FF,\n};\n}\n};\nconst Status = enum(u8) {\nidle = 0,\nrunning = 1,\nerror = 2,\ndone = 3,\n};\nconst Result = union(enum) {\nok: i32,\nerr: []const u8,\npub fn isOk(self: Result) bool {\nreturn self == .ok;\n}\n};\nconst ExternData = extern union {\nint_val: i32,\nfloat_val: f32,\nbytes: [4]u8,\n};\nconst MAX_SIZE: usize = 1024;\npub var global_state: i32 = 0;\nconst MAGIC_NUMBER: u32 = comptime blk: {\nvar x: u32 = 1;\nx *= 42;\nbreak :blk x;\n};\nconst ParseError = error{\nInvalidInput,\nUnexpectedToken,\nEndOfStream,\nBufferOverflow,\n};\ntest \"add returns correct sum\" {\nconst result = add(2, 3);\ntry std.testing.expectEqual(@as(i32, 5), result);\n}\ntest \"safeDivide handles zero\" {\nconst result = safeDivide(10, 0);\ntry std.testing.expectError(error.DivisionByZero, result);\n}\ntest \"indexOf finds element\" {\nconst items = [_]i32{ 1, 2, 3, 4, 5 };\nconst idx = indexOf(i32, &items, 3);\ntry std.testing.expectEqual(@as(?usize, 2), idx);\n}\nconst io = @import(\"std\");\nconst fs = @import(\"std\");\nconst mem = @import(\"std\");\nconst math = @import(\"std\");\nconst json = @import(\"std\");\nconst Mode = enum { fast, safe };\nconst Phase = enum { init, done };\nconst Signal = enum { on, off };\nconst Packet = struct { id: i32 };\nconst Limits = struct { max: i32 };\nconst Variant = union { i: i32, f: f32 };\nconst Payload = extern union { a: i32, b: i32 };\nconst Message = union { txt: [4]u8, len: u32 };\nvar retries: i32 = 0;\nvar pointer: usize = 0;\nfn reqCoverZig1(value: i32) i32 { return value + 1; }\nfn reqCoverZig2(value: i32) i32 { return value + 2; }\nfn reqCoverZig3(value: i32) i32 { return value + 3; }\nfn reqCoverZig4(value: i32) i32 { return value + 4; }\nfn reqCoverZig5(value: i32) i32 { return value + 5; }\n```\n",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/enable-static-check-invalid-command.json

@@ -1,5 +0,0 @@
-{
-  "code": 1,
-  "stdout": "",
-  "stderr": "Error: --enable-static-check Command cmd 'nonexistent_tool_xyz_12345' is not an executable program on this system.\n"
-}

package/tests/fixtures_attended_results/project/enable-static-check-valid.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "",
-  "stderr": ""
-}

package/tests/fixtures_attended_results/project/files-static-check.json

@@ -1,5 +0,0 @@
-{
-  "code": 1,
-  "stdout": "# Static-Check(Command[false]): <PROJECT_BASE>/src/fixture_python.py\nResult: FAIL\nEvidence:\n\n\n",
-  "stderr": ""
-}