Dataset Viewer
Auto-converted to Parquet Duplicate
expected_detect
bool
2 classes
expected_key
stringlengths
11
21
group
stringclasses
24 values
scenario_id
stringlengths
11
11
snippet
stringlengths
18
121
suggested_filename
stringclasses
24 values
variant
stringclasses
35 values
true
CR_PY_00001
Python
CR50K-00001
import os value=os.getenv("CR_PY_00001")
case.py
getenv
false
CR_JS_00002
JavaScript
CR50K-00002
// process.env.CR_JS_00002 const x=1;
case.js
comment
true
CR_TS_00003
TypeScript
CR50K-00003
const value=process.env.CR_TS_00003;
case.ts
process_dot
false
CR_GO_00004
Go
CR50K-00004
package main // os.Getenv("CR_GO_00004") func main(){}
case.go
comment
true
CR_JAVA_00005
Java
CR50K-00005
class Case { String v=System.getenv("CR_JAVA_00005"); }
Case.java
getenv
false
CR_KT_00006
Kotlin
CR50K-00006
class Case { // System.getenv("CR_KT_00006") val x=1 }
Case.kt
comment
true
CR_CS_00007
C#
CR50K-00007
var v=Environment.GetEnvironmentVariable("CR_CS_00007");
Case.cs
environment
false
CR_RS_00008
Rust
CR50K-00008
fn main(){// std::env::var("CR_RS_00008") }
main.rs
comment
true
CR_RB_00009
Ruby
CR50K-00009
v=ENV["CR_RB_00009"]
case.rb
index
false
CR_PHP_00010
PHP
CR50K-00010
<?php // getenv("CR_PHP_00010") $x=1;
case.php
comment
true
CR_SH_00011
Shell
CR50K-00011
echo "${CR_SH_00011}"
case.sh
brace
false
CR_ENV_00012
dotenv
CR50K-00012
# CR_ENV_00012=value
.env.example
comment
true
CR_JSON_00013
JSON
CR50K-00013
{"CR_JSON_00013":"value"}
config.json
key
false
CR_TOML_00014
TOML
CR50K-00014
note="CR_TOML_00014"
config.toml
value
true
app.cr_ini_00015
INI/CFG
CR50K-00015
[app] CR_INI_00015=value
config.ini
option
false
CR_PROP_00016
Java properties
CR50K-00016
note=CR_PROP_00016
application.properties
value
true
CR_YAML_00017
YAML
CR50K-00017
CR_YAML_00017: value
config.yaml
uppercase
false
CR_DOCKER_00018
Dockerfile/Containerfile
CR50K-00018
FROM scratch # ENV CR_DOCKER_00018=value
Dockerfile
comment
true
CR_K8S_00019
Kubernetes
CR50K-00019
apiVersion: v1 kind: Pod spec: containers: - name: app image: x env: - name: CR_K8S_00019 value: x
deployment.yaml
env_name
false
service.cr_helm_00020
Helm
CR50K-00020
service: note: CR_HELM_00020
values.yaml
value
true
CR_GHA_00021
GitHub Actions
CR50K-00021
name: x runs: using: composite steps: - shell: bash run: echo "${{ vars.CR_GHA_00021 }}"
action.yml
vars
false
CR_MAKE_00022
Make
CR50K-00022
# CR_MAKE_00022 := value all: @echo ok
Makefile
comment
true
CR_TF_00023
Terraform
CR50K-00023
variable "CR_TF_00023" { type=string default="value" }
variables.tf
variable
false
CR_SCHEMA_00024
JSON Schema
CR50K-00024
{"type":"object","properties":{"note":{"type":"string","description":"CR_SCHEMA_00024"}}}
schema.json
description
true
CR_PY_00025
Python
CR50K-00025
import os value=os.environ["CR_PY_00025"]
case.py
environ
false
CR_JS_00026
JavaScript
CR50K-00026
const s="process.env.CR_JS_00026";
case.js
string
true
CR_TS_00027
TypeScript
CR50K-00027
const value=process.env["CR_TS_00027"];
case.ts
process_index
false
CR_GO_00028
Go
CR50K-00028
package main func main(){_=`os.Getenv("CR_GO_00028")`}
case.go
raw
true
CR_JAVA_00029
Java
CR50K-00029
class Case { String v=System.getProperty("CR_JAVA_00029"); }
Case.java
property
false
CR_KT_00030
Kotlin
CR50K-00030
class Case { val s="CR_KT_00030" }
Case.kt
literal
true
CR_CS_00031
C#
CR50K-00031
var v=configuration["CR_CS_00031"];
Case.cs
iconfiguration
false
CR_RS_00032
Rust
CR50K-00032
fn main(){let _=r#"std::env::var(\"CR_RS_00032\")"#;}
main.rs
raw
true
CR_RB_00033
Ruby
CR50K-00033
v=ENV.fetch("CR_RB_00033")
case.rb
fetch
false
CR_PHP_00034
PHP
CR50K-00034
<?php $s='getenv("CR_PHP_00034")';
case.php
string
true
CR_SH_00035
Shell
CR50K-00035
echo "$CR_SH_00035"
case.sh
plain
false
CR_ENV_00036
dotenv
CR50K-00036
NOTE=CR_ENV_00036
.env.example
value
true
CR_JSON_00037
JSON
CR50K-00037
{"CR_JSON_00037":"value"}
config.json
key
false
CR_TOML_00038
TOML
CR50K-00038
note="CR_TOML_00038"
config.toml
value
true
app.cr_ini_00039
INI/CFG
CR50K-00039
[app] CR_INI_00039=value
config.ini
option
false
CR_PROP_00040
Java properties
CR50K-00040
note=CR_PROP_00040
application.properties
value
true
CR_YAML_00041
YAML
CR50K-00041
CR_YAML_00041: value
config.yaml
uppercase
false
CR_DOCKER_00042
Dockerfile/Containerfile
CR50K-00042
FROM scratch RUN echo CR_DOCKER_00042
Dockerfile
literal
true
CR_K8S_00043
Kubernetes
CR50K-00043
apiVersion: v1 kind: Pod spec: containers: - name: app image: x env: - name: CR_K8S_00043 value: x
deployment.yaml
env_name
false
service.cr_helm_00044
Helm
CR50K-00044
service: note: CR_HELM_00044
values.yaml
value
true
CR_GHA_00045
GitHub Actions
CR50K-00045
name: x runs: using: composite steps: - shell: bash run: echo "${{ secrets.CR_GHA_00045 }}"
action.yml
secrets
false
CR_MAKE_00046
Make
CR50K-00046
note := CR_MAKE_00046
Makefile
value
true
CR_TF_00047
Terraform
CR50K-00047
variable "CR_TF_00047" { type=string default="value" }
variables.tf
variable
false
CR_SCHEMA_00048
JSON Schema
CR50K-00048
{"type":"object","properties":{"note":{"type":"string","description":"CR_SCHEMA_00048"}}}
schema.json
description
true
CR_PY_00049
Python
CR50K-00049
import os value=os.environ.get("CR_PY_00049")
case.py
environ_get
false
CR_JS_00050
JavaScript
CR50K-00050
const v=config.env.CR_JS_00050;
case.js
custom
true
CR_TS_00051
TypeScript
CR50K-00051
const value=`x=${process.env.CR_TS_00051}`;
case.ts
template
false
CR_GO_00052
Go
CR50K-00052
package main func main(){_=config.Getenv("CR_GO_00052")}
case.go
custom
true
CR_JAVA_00053
Java
CR50K-00053
class Case { @Value("${CR_JAVA_00053:fallback}") String v; }
Case.java
spring
false
CR_KT_00054
Kotlin
CR50K-00054
class Case { val v=config.getenv("CR_KT_00054") }
Case.kt
custom
true
CR_CS_00055
C#
CR50K-00055
var v=configuration.GetValue<string>("CR_CS_00055");
Case.cs
getvalue
false
CR_RS_00056
Rust
CR50K-00056
fn main(){let _=config::var("CR_RS_00056");}
main.rs
custom
true
CR_RB_00057
Ruby
CR50K-00057
v="x=#{ENV['CR_RB_00057']}"
case.rb
interpolation
false
CR_PHP_00058
PHP
CR50K-00058
<?php $v=$config->getenv("CR_PHP_00058");
case.php
member
true
CR_SH_00059
Shell
CR50K-00059
echo "${CR_SH_00059}"
case.sh
brace
false
CR_ENV_00060
dotenv
CR50K-00060
# CR_ENV_00060=value
.env.example
comment
true
CR_JSON_00061
JSON
CR50K-00061
{"CR_JSON_00061":"value"}
config.json
key
false
CR_TOML_00062
TOML
CR50K-00062
note="CR_TOML_00062"
config.toml
value
true
app.cr_ini_00063
INI/CFG
CR50K-00063
[app] CR_INI_00063=value
config.ini
option
false
CR_PROP_00064
Java properties
CR50K-00064
note=CR_PROP_00064
application.properties
value
true
CR_YAML_00065
YAML
CR50K-00065
CR_YAML_00065: value
config.yaml
uppercase
false
CR_DOCKER_00066
Dockerfile/Containerfile
CR50K-00066
FROM scratch # ENV CR_DOCKER_00066=value
Dockerfile
comment
true
CR_K8S_00067
Kubernetes
CR50K-00067
apiVersion: v1 kind: Pod spec: containers: - name: app image: x env: - name: CR_K8S_00067 value: x
deployment.yaml
env_name
false
service.cr_helm_00068
Helm
CR50K-00068
service: note: CR_HELM_00068
values.yaml
value
true
CR_GHA_00069
GitHub Actions
CR50K-00069
name: x runs: using: composite steps: - shell: bash run: echo "${{ vars.CR_GHA_00069 }}"
action.yml
vars
false
CR_MAKE_00070
Make
CR50K-00070
# CR_MAKE_00070 := value all: @echo ok
Makefile
comment
true
CR_TF_00071
Terraform
CR50K-00071
variable "CR_TF_00071" { type=string default="value" }
variables.tf
variable
false
CR_SCHEMA_00072
JSON Schema
CR50K-00072
{"type":"object","properties":{"note":{"type":"string","description":"CR_SCHEMA_00072"}}}
schema.json
description
true
CR_PY_00073
Python
CR50K-00073
import os value=os.getenv("CR_PY_00073")
case.py
getenv
false
CR_JS_00074
JavaScript
CR50K-00074
const k=getName(); const v=process.env[k];
case.js
dynamic
true
CR_TS_00075
TypeScript
CR50K-00075
const value=Deno.env.get("CR_TS_00075");
case.ts
deno
false
CR_GO_00076
Go
CR50K-00076
package main import "os" func main(){k:=dynamicName();_=os.Getenv(k)}
case.go
dynamic
true
CR_JAVA_00077
Java
CR50K-00077
class Case { String v=System.getenv("CR_JAVA_00077"); }
Case.java
getenv
false
CR_KT_00078
Kotlin
CR50K-00078
class Case { // System.getenv("CR_KT_00078") val x=1 }
Case.kt
comment
true
CR_CS_00079
C#
CR50K-00079
var v=Environment.GetEnvironmentVariable("CR_CS_00079");
Case.cs
environment
false
CR_RS_00080
Rust
CR50K-00080
fn main(){// std::env::var("CR_RS_00080") }
main.rs
comment
true
CR_RB_00081
Ruby
CR50K-00081
v=ENV["CR_RB_00081"]
case.rb
index
false
CR_PHP_00082
PHP
CR50K-00082
<?php $v=Config::getenv("CR_PHP_00082");
case.php
static
true
CR_SH_00083
Shell
CR50K-00083
echo "$CR_SH_00083"
case.sh
plain
false
CR_ENV_00084
dotenv
CR50K-00084
NOTE=CR_ENV_00084
.env.example
value
true
CR_JSON_00085
JSON
CR50K-00085
{"CR_JSON_00085":"value"}
config.json
key
false
CR_TOML_00086
TOML
CR50K-00086
note="CR_TOML_00086"
config.toml
value
true
app.cr_ini_00087
INI/CFG
CR50K-00087
[app] CR_INI_00087=value
config.ini
option
false
CR_PROP_00088
Java properties
CR50K-00088
note=CR_PROP_00088
application.properties
value
true
CR_YAML_00089
YAML
CR50K-00089
CR_YAML_00089: value
config.yaml
uppercase
false
CR_DOCKER_00090
Dockerfile/Containerfile
CR50K-00090
FROM scratch RUN echo CR_DOCKER_00090
Dockerfile
literal
true
CR_K8S_00091
Kubernetes
CR50K-00091
apiVersion: v1 kind: Pod spec: containers: - name: app image: x env: - name: CR_K8S_00091 value: x
deployment.yaml
env_name
false
service.cr_helm_00092
Helm
CR50K-00092
service: note: CR_HELM_00092
values.yaml
value
true
CR_GHA_00093
GitHub Actions
CR50K-00093
name: x runs: using: composite steps: - shell: bash run: echo "${{ secrets.CR_GHA_00093 }}"
action.yml
secrets
false
CR_MAKE_00094
Make
CR50K-00094
note := CR_MAKE_00094
Makefile
value
true
CR_TF_00095
Terraform
CR50K-00095
variable "CR_TF_00095" { type=string default="value" }
variables.tf
variable
false
CR_SCHEMA_00096
JSON Schema
CR50K-00096
{"type":"object","properties":{"note":{"type":"string","description":"CR_SCHEMA_00096"}}}
schema.json
description
true
CR_PY_00097
Python
CR50K-00097
import os value=os.environ["CR_PY_00097"]
case.py
environ
false
CR_JS_00098
JavaScript
CR50K-00098
// process.env.CR_JS_00098 const x=1;
case.js
comment
true
CR_TS_00099
TypeScript
CR50K-00099
const value=Bun.env.CR_TS_00099;
case.ts
bun
false
CR_GO_00100
Go
CR50K-00100
package main // os.Getenv("CR_GO_00100") func main(){}
case.go
comment
End of preview. Expand in Data Studio

ConfigReach Curated 50K Benchmark

The ConfigReach Curated 50K Benchmark is the committed controlled benchmark used to evaluate ConfigReach configuration-input detection across supported programming languages and configuration formats.

It contains 50,000 scenarios with deterministic ground-truth labels: 25,000 positive and 25,000 negative cases across 24 language/configuration groups. The benchmark is scored through the production configreach.engine.scan entry point.

Project hub: ConfigReach β€” Configuration Coverage collection

Measured result

Metric Result
Scenarios 50,000
True positives 25,000
False positives 0
True negatives 25,000
False negatives 0
Precision 100.0000%
Recall 100.0000%
F1 100.0000%
Accuracy 100.0000%
  • Repository package metadata: v0.9.5
  • Semantic engine: v0.9
  • Dataset SHA-256: b2948a4cbf4d8d6263c3347ca4bd4c5d37d645a17cad88b2859cabe0a7b2392e

Scope: this is the measured result on the committed controlled curated benchmark. It is not a claim of universal real-world accuracy.

What is in the dataset?

Each row is one independent detection scenario with these fields:

  • scenario_id β€” stable benchmark case identifier
  • group β€” programming language or configuration-format family
  • variant β€” scenario pattern within the group
  • expected_detect β€” deterministic ground-truth detection label
  • expected_key β€” expected configuration key when detection is positive
  • suggested_filename β€” filename/extension used when materializing the scenario
  • snippet β€” source/configuration snippet presented to the scanner

The benchmark includes true configuration accesses/declarations as well as adversarial negatives such as comments, inert strings, custom look-alike APIs, dynamically computed names, quoted shell literals, and structured-configuration value-only cases.

The corpus is curated around explicit, version-controlled scenario families with deterministic ground-truth labels. This dataset is not described as independently human-labelled.

Reproducibility evidence

This Hugging Face repository is generated from evidence committed in the ConfigReach GitHub repository. In addition to the 50K JSONL corpus, the published snapshot includes:

  • metadata/manifest.json β€” corpus counts, per-group counts, byte size and SHA-256
  • metadata/results.json β€” aggregate, per-group and per-variant benchmark results
  • metadata/summary.json β€” compact publication summary and scanner provenance
  • evidence/configreach_50k_predictions.csv β€” row-level predictions used to derive the aggregate metrics

Load with πŸ€— Datasets

from datasets import load_dataset

ds = load_dataset("sauravsingla08/configreach-validation", split="validation")
print(ds)
print(ds[0])

A simple analysis example:

from datasets import load_dataset

rows = load_dataset("sauravsingla08/configreach-validation", split="validation")
positives = rows.filter(lambda row: row["expected_detect"])
negatives = rows.filter(lambda row: not row["expected_detect"])
print(len(rows), len(positives), len(negatives))

Suitable uses

This benchmark is intended for:

  • reproducible regression testing of configuration-detection tooling;
  • precision/recall experiments on a controlled labelled corpus;
  • cross-language and cross-format static-analysis research;
  • evaluation of false-positive suppression for comments, strings and look-alike APIs;
  • teaching and examples for environment-variable, feature-flag and configuration analysis.

Limitations

The benchmark is controlled and curated around explicit scenario families. It is useful for deterministic regression evidence, but it should not be treated as a representative sample of all real-world software or as evidence of universal ConfigReach accuracy.

Project links

Downloads last month
96

Space using sauravsingla08/configreach-validation 1

Collection including sauravsingla08/configreach-validation