rachna1508/ossbridge-results

OSSBridge results

How Java libraries on Maven Central are used by the projects that depend on them, and how well the libraries' own test suites cover the APIs those projects use. Produced by the OSSBridge data pipeline and read by the OSSBridge app.

9 library versions (updated 2026-11-03):

Library	Version	Source	Dependents using it (selected)	Test coverage	Tests	API coverage
com.fasterxml.jackson.core:jackson-databind	2.12.7.2	pipeline	7 (7)	ok	2,601	78.1%
com.fasterxml.jackson.core:jackson-databind	2.17.2	pipeline	408 (400)	ok	4,131	78.8%
commons-codec:commons-codec	1.12	pipeline	334 (334)	ok	903	85.8%
commons-codec:commons-codec	1.16.0	pipeline	107 (100)	ok	1,336	93.6%
commons-codec:commons-codec	1.16.1	pipeline	232 (232)	ok	1,699	87.1%
commons-codec:commons-codec	1.17.1	pipeline	87 (87)	ok	1,716	93.7%
org.mybatis:mybatis	3.5.14	pipeline	41 (41)	ok	1,771	85.3%
org.mybatis:mybatis	3.5.15	pipeline	71 (50)	ok	1,775	85.3%
org.mybatis:mybatis	3.5.16	pipeline	76 (76)	ok	1,769	85.1%

Tables

All tables are Parquet files, one per library version, under results/<table>/. Every table starts with library_ga (groupId:artifactId) and version.

Table	Contents
library_versions	One row per library version: dependents found, tried, using the library and selected; test coverage status, tests run and API coverage.
apis	The API of the library jar: each class member a dependent can use (public, and protected unless the class is final), with deprecation and module export information.
dependents	Each dependent project that was tried: its release, rank, reach, download status, whether it uses the library and whether it was selected.
api_usage	Uses of the library by each selected dependent, per target and category (method call, method reference, field access, type reference, annotation, ...), with the declaring class and the number of occurrences and calling classes.
api_coverage	Coverage of each API method and constructor by the library's own test suite (JaCoCo), including coverage through overriding methods.
runs	Provenance: one row per pipeline or conversion run, with its parameters and summaries as JSON.

An API is identified by api_id: <package>.<Class>.<member><descriptor> for methods and constructors (<init>), and <package>.<Class>.<field>:<descriptor> for fields. In api_usage it is the API of the declaring class, so usage joins with apis and api_coverage on (library_ga, version, api_id).

Columns:

• library_versions: library_ga, version, packages, run_id, dependent_projects, dependents_tried, dependents_using, dependents_selected, target_reached, coverage_status, tests, api_coverage_pct, instructions_missed, instructions_covered
• apis: library_ga, version, api_id, package, class_name, member, descriptor, kind, visibility, static, abstract, class_kind, deprecated, deprecated_for_removal, class_deprecated, exported
• dependents: library_ga, version, dependent_ga, dependent_version, release_ts, tier, rank, reach, download_status, uses_library, selected, analyzed, bytecode_instructions
• api_usage: library_ga, version, dependent_ga, dependent_version, category, target_class, target_member, target_descriptor, declaring_class, resolution, api_id, occurrences, caller_classes
• api_coverage: library_ga, version, api_id, status, overrides, overrides_covered, instruction_missed, instruction_covered, branch_missed, branch_covered, line_missed, line_covered, complexity_missed, complexity_covered
• runs: run_id, kind, started_at, params

dependents-index/ holds the index of which projects depend on which library version that the pipeline selects dependents from: edges.parquet (every dependency in the Goblin graph of Maven Central), releases.parquet (the release date of each dependent release), reach.parquet (for each artifact, the number of distinct artifacts that depend on any of its versions), and the summaries versions.parquet and libraries.parquet (dependent projects per library version and per library).

How the data is produced

For each library version, the pipeline:

1. lists the projects that depend on it (dependents index, built from the Goblin Maven Central dependency graph), keeping each project's latest release and dropping test-scoped dependencies;
2. downloads dependents' jars from Maven Central and
3. analyzes their bytecode (ASM) until enough dependents that use the library are found: a top tier by reach and a random tier; dependents that only declare the dependency are counted but not selected;
4. lists the library's API from its jar;
5. builds the library from its release tag and runs its test suite with JaCoCo;
6. matches coverage to each API, following overriding methods;
7. writes these tables.

Every downloaded jar's SHA-256 and the analyzer's SHA-256 are kept in the run summaries (runs), so the usage analysis can be reproduced.

Limitations

• Dependents come from a snapshot of Maven Central (Goblin, 20 April 2025); releases after it have no dependents in the index.
• Versions analyzed before the index had reach values (31 October 2026) selected all dependents at random; each run's settings, including top_target, are in runs.
• Test coverage needs a GitHub repository with a release tag and a Maven or Gradle build; coverage_status says why when there is none.
• Versions converted from the original dataset have no deprecation or override information, and their usage is recorded on the class named in the bytecode.

Use

import duckdb
duckdb.sql("""
    SELECT * FROM 'hf://datasets/rachna1508/ossbridge-results/results/library_versions/*.parquet'
""").show()

from datasets import load_dataset
apis = load_dataset("rachna1508/ossbridge-results", "apis", split="train")

Contact

Questions and problems: https://github.com/CuriousBeing1508/OSSBridge/issues