MultiOOP: Multi-Language OOP Benchmark

• MultiOOP is a comprehensive, multi-language benchmark that rigorously evaluates LLMs’ object-oriented programming code generation capabilities.
• It employs a systematic translation pipeline and augmented test cases to ensure robust, concept-level testing via pass@k and pass@o metrics.
• Results highlight significant structural fidelity gaps and cross-language variability, underscoring the need for refined tuning strategies in LLMs.

MultiOOP is a large-scale, contamination-controlled, multi-language benchmark designed to rigorously evaluate the object-oriented programming (OOP) code generation capabilities of LLMs. It addresses critical gaps in prior benchmarks by enabling assessment across six widely used programming languages and by enforcing concept-level fidelity and robust statistical evaluation in each code generation task (Wang et al., 30 Sep 2025).

1. Motivation and Background

A survey of 35 benchmarks for LLM code generation, including HumanEval, MBPP, and JavaBench, identified three pervasive limitations: (1) more than 85% focus exclusively on a single language, predominantly Python; (2) over 94% assess only function-level or statement-level tasks, with nearly all OOP evaluation confined to Python; (3) over 80% provide fewer than ten test cases per problem, resulting in unreliable measurement of generalization and correctness. These deficiencies stand in stark contrast to real-world software engineering practices, which are inherently multi-language and deeply reliant on OOP constructs (e.g., classes, inheritance, encapsulation, and polymorphism). Existing benchmarks therefore fail to assess an LLM's ability to generate complex, conceptually faithful OOP solutions across diverse languages (Wang et al., 30 Sep 2025).

2. Benchmark Construction and Translation

MultiOOP is designed by extending the existing Python-only “OOP” benchmark, which originally consisted of 431 tasks. Of these, 267 language-agnostic tasks were retained, specifically excluding any problem dependent on Python idiosyncrasies (such as list comprehensions, multiple inheritance, or reliance on external libraries). The selected set was then systematically translated into six major programming languages: Python, PHP, C++, C#, Java, and JavaScript. Language selection was informed by global usage frequency across TIOBE, PYPL, GitHut, and RedMonk rankings, covering both high- and low-prevalence languages (Wang et al., 30 Sep 2025).

The translation pipeline comprises three stages:

1. Prompt Translation: Natural-language task requirements are adapted only as necessary, preserving code snippets when present.
2. Unit-Test Conversion: Python-based test code is mapped to each target language by rewriting type annotations, assertion statements (e.g., assert, Debug.Assert, console.assert), statement terminators, and specific OOP patterns such as inheritance syntax, access specifiers, constructors, and instantiation.
3. Key-Point Extraction: The “pass@o” evaluation metric (see below) depends on language-specific detection of class/method names and other key tokens, necessitating precise mapping for each syntax (Wang et al., 30 Sep 2025).

The outcome is a benchmark suite comprising 1,602 independent OOP problems (267 tasks in each of six languages).

3. Evaluation Metrics: pass@k and pass@o

MultiOOP introduces an extension of the conventional pass@k metric to explicitly measure an LLM's adherence to OOP abstractions via the pass@o metric.

• pass@k: For each problem, pass@k quantifies the probability that at least one out of k random samples passes all test cases:

$$\text{pass@}k := \mathbb{E}_{\text{problems}}\left[1 - \frac{{\binom{n-c}{k}}}{{\binom{n}{k}}}\right]$$

where $n$ is the number of generated candidates, and $c$ the number passing all dynamic unit tests.

• pass@o: This stronger measure requires a sample to both pass all unit tests and include all required OOP structural elements (e.g., class and method names):

$$f(X_i) = \begin{cases} 1 & \text{if } X_i \text{ passes all tests and matches all } m \text{ key OOP tokens} \ 0 & \text{otherwise} \end{cases}$$

Define $\alpha = \sum_{i=1}^{n} f(X_i)$. Then,

$$\text{pass@}o := \mathbb{E}_{\text{problems}}\left[1 - \frac{{\binom{n-\alpha}{k}}}{{\binom{n}{k}}}\right]$$

pass@o thus measures semantic and syntactic conformance to the prescribed OOP specification, not mere functional equivalence (Wang et al., 30 Sep 2025).

4. Automated and Augmented Evaluation

To mitigate false positives and statistical fragility, MultiOOP attaches an average of 20 rigorously validated test cases per problem—compared to the 2–10 typically found in prior benchmarks. Test cases are expanded automatically by prompting a powerful LLM (GPT-4o) with reference solutions and extant test cases to generate additional, diverse scenarios targeting both standard and edge cases. These supplemental cases are tested against the reference Python implementation and only those that pass are then translated through the same language pipeline into all target languages. This guarantees that test coverage is both broad and reliable, sharply reducing the probability of spurious pass@k or pass@o scores due to insufficient or unrepresentative evaluation data (Wang et al., 30 Sep 2025).

5. Experimental Protocol and Results

Benchmark evaluation was performed on 14 leading LLMs, comprising both general-purpose and code-specialized models (Llama 3 variants, Phi-3, Qwen 2.5, Vicuna, CodeLlama, StarCoder, WizardCoder, and GPT-4o mini). Most tests used zero-shot prompting (“write the requested class and methods”) as well as zero-shot chain-of-thought (CoT) and few-shot exemplars for ablation. Sampling was done with $n \ge 15$ solutions per task, reporting pass@1, pass@8, pass@15.

Key findings include:

• Severe Performance Drop: Models exhibited substantial pass@1 degradation relative to canonical function-level benchmarks (e.g., HumanEval). For instance, GPT-4o mini, the strongest model tested, achieved pass@1 = 48.06% in Python, 23.05% in C++, 16.98% in Java, 21.72% in C#, 57.63% in PHP, and 52.36% in JavaScript.
• Cross-Language Variability: There is strong nonuniformity: LLM performance on low-frequency languages (PHP, C#) can match or exceed more prevalent ones (Java, C++), refuting the assumption that frequency directly determines task difficulty.
• Conceptual Gaps in Generation: For all models and languages, pass@o is consistently 1.1–19.2 points below pass@k, demonstrating that code may be fully executable yet deficient in OOP structural fidelity (e.g., incorrect class/method naming or missing constructs).
• Prompting Effects: Few-shot prompting can yield up to +24 gain in pass@o (e.g., Qwen2.5-14b, Python). Zero-shot CoT prompts provide more modest, variable improvements.
• Test Case Coverage: Increased test set size (from 3 to 15+) leads to a pronounced drop in reported pass rates, plateauing beyond 15–18 cases. This suggests prior benchmarks likely exaggerate LLM performance due to under-testing (Wang et al., 30 Sep 2025).

6. Implications for OOP Code Generation Research

MultiOOP exposes significant OOP generalization failures in state-of-the-art LLMs, even for those achieving high functional scores on simpler code generation benchmarks. The observed discrepancies between pass@k and pass@o directly quantify persistent conceptual gaps—generated code often "happens to run," but is structurally incorrect per the user's OOP intent.

By providing a contamination-controlled, multilingual, and concept-driven testing environment, MultiOOP enables precise diagnosis of model training deficiencies, detailed studies of cross-language transfer, and principled benchmarking for new training regimes or architectural innovations. Researchers are positioned to employ MultiOOP not only as a rigorous evaluation tool but also as a scaffold for developing and validating OOP-focused fine-tuning strategies and diagnostic techniques (Wang et al., 30 Sep 2025).

7. Data Release and Availability

All code, translation pipelines, test-case augmentation scripts, and the final 1,602-problem MultiOOP benchmark suite are openly available:

• GitHub – evaluation and translation framework
• HuggingFace – full dataset

This ensures reproducibility, facilitates further research on LLM code generation, and sets a new standard for comprehensive and multi-dimensional evaluation of OOP competence across LLMs.

---

MultiOOP thus fills a critical evaluation blind spot for LLM benchmarks, uniquely combining multi-language OOP coverage, structural semantic enforcement (pass@o), and robust test case augmentation. It establishes a foundation for future studies in cross-language code generation, OOP-aware training, and robust benchmarking of next-generation code models (Wang et al., 30 Sep 2025).