Manju46/kotlin-test-pairs

KotlinTestPairs

9,856 Kotlin source↔unit-test pairs ("focal method" pairs) mined from permissively licensed public GitHub code.

Applies the methods2test (MSR 2022) methodology to Kotlin, and is the sibling of SwiftTestPairs.

⚠️ This dataset contains NO source code

Rows are references + derived metadata: repository, file paths, content MD5s, and measured properties. The code stays where it has always been, in the upstream corpus. This avoids redistributing anyone's source, and it honours upstream opt-outs automatically — a file withdrawn from the corpus simply fails to resolve.

The contribution here is the pairing and the measurements, not the source.

Every row is permissively licensed. There is no copyleft and no unlicensed code in it:

licence	pairs	share
Apache-2.0	6,347	64.4%
MIT	2,744	27.8%
BSD-3-Clause	493	5.0%
ISC	134	1.4%
Unlicense	104	1.1%
CC0-1.0	27	0.3%
BSD-2-Clause, Artistic-2.0	7	0.1%

Schema

column	description
pair_id	md5 of repo:source_path:test_path
repo_name, source_path, test_path	location of the focal file and its test
target_type	the type under test, derived from the test filename
source_content_md5, test_content_md5	verify resolution fidelity
source_bytes, test_bytes	file sizes
n_assertions, n_test_methods	measured from the test file
license	SPDX identifier, carried per row so you can filter
source_uses_coroutines, test_uses_coroutines	suspend / runTest / runBlocking present
test_uses_kotest	imports io.kotest rather than JUnit or kotlin.test
test_uses_mocking	imports MockK or Mockito
split	train / valid / test, assigned by repository

The data

	pairs	repos
train	7,523	1,071
valid	1,196	151
test	1,137	158
total	9,856	1,380

Splits are assigned by repository, not by pair, so no repository appears in more than one split. A pair-level split would let a model see one test from a repository in training and be scored on its sibling.

Median pair: 9 assertions across 5 test methods, a 2.7 KB source file and a 3.5 KB test.

Measured ecosystem facts, which the Swift sibling has no equivalent of:

	share of pairs
tests using MockK or Mockito	17.9%
tests using coroutines	10.2%
sources using coroutines	12.6%
tests using Kotest	0.3%

Kotest's 0.3% is worth knowing before you assume a project uses it: JUnit and kotlin.test are what almost everyone writes.

⚠️ There is no verified-to-compile tier, and there cannot be one

SwiftTestPairs has a tier of 569 pairs verified to build. This dataset has no equivalent, and no Kotlin dataset built from public corpora can have one.

Every public Kotlin corpus is .kt-only. Not one carries a build manifest:

corpus	build files
mvasiliniuc/iva-kotlin-codeint	0
softh/alt-kotlin-source	0 build.gradle, 0 .kts, 0 pom.xml
HuggingFaceTB/stack-edu	no Kotlin configuration at all
giggiovpg/...compiler-verified	synthetic, model-generated, empty test bodies
GD-ML/AndroidCode	UI traces, not source

Without build.gradle or settings.gradle.kts, a Gradle project cannot be built. So no pair here can be compiled, and no benchmark that needs a building project can run on this data.

Swift only worked by accident. Package.swift survived its corpus's extension filter because it happens to end in .swift. Kotlin's manifests are .gradle and .kts, so every one was dropped before the corpus was ever published.

That is the finding worth taking from this section: a corpus's extension filter silently destroys buildability, and whether a language survives it is luck about file naming. Anyone building a code corpus should keep the manifests.

Construction

1. Classify every .kt file in the corpus as source or test. 7.7% are tests — against 2.3% in the Swift corpus, so Kotlin is considerably denser in tests.
2. Join on the JUnit naming convention: Foo.kt ↔ FooTest.kt in the same repository. Join rate 55.5%, giving 11,349 raw pairs.
3. Deduplicate. Exact content match removed 2. Near-duplicate detection (MinHash/LSH, Jaccard 0.8) removed a further 1,491 — 13.1%.
4. Split by repository, then check for leakage across splits.

From 464,215 files to 9,856 pairs.

Known limitations

• No verified tier, for the reason above. If you need pairs that compile, you need a corpus that kept its build files, and none exists.
• Filename join only. Foo.kt ↔ FooTest.kt catches the common convention and misses tests named otherwise. It favours projects that follow it.
• target_type is derived from the test filename, not from parsing. A test named FooTest.kt is assumed to test Foo.
• Assertion counts are lexical. n_assertions counts assertion-shaped calls; a helper that asserts internally is counted once.
• A long tail of outliers. One pair reports 1,198 assertions. Filter on n_assertions if you need a sane range.
• Not a quality signal. A pair being present says a test exists, not that it is good.

Provenance

Built from mvasiliniuc/iva-kotlin-codeint — 464,215 .kt files, of which 82.2% carry a permissive licence. Only the permissively licensed ones are represented here.

Removal requests

If your repository appears in this dataset and you would like it removed, please open a Discussion on this dataset and name the repository. I will drop those rows and re-publish. No justification needed.

Note that this dataset contains no source code — only repository names, file paths, content fingerprints and measurements. The code itself remains where it has always been, in the upstream corpus listed above.

Citation

@misc{kotlintestpairs2026,
  title  = {KotlinTestPairs: Kotlin source-to-test pairs from permissively licensed public code},
  author = {Swamy Manju},
  year   = {2026},
  url    = {https://huggingface.co/datasets/Manju46/kotlin-test-pairs}
}