Datasets:
content large_stringlengths 48 7.98M | membership large_stringclasses 2
values |
|---|---|
package crypto
import (
"encoding/hex"
"testing"
"github.com/XunleiBlockchain/tc-libs/common"
"github.com/stretchr/testify/assert"
)
func TestGeneratePrivKey(t *testing.T) {
testPriv, err := GenPrivKeyEd25519()
if err != nil {
t.Fatalf("GenPrivKeyEd25519 fail: %s", err)
}
testGenerate := testPriv.Generate(... | non-member |
package aws
import (
"github.com/aws/aws-sdk-go/aws"
elasticsearch "github.com/aws/aws-sdk-go/service/elasticsearchservice"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
)
func expandAdvancedSecurityOptions(m []interface{}) *elasticsearch.AdvancedSecurityOptionsInput {
config := elasticsearch.Advan... | non-member |
package otto
import (
"bytes"
"encoding/json"
"fmt"
"strings"
)
type _builtinJSON_parseContext struct {
call FunctionCall
reviver Value
}
func builtinJSON_parse(call FunctionCall) Value {
ctx := _builtinJSON_parseContext{
call: call,
}
revive := false
if reviver := call.Argument(1); reviver.isCallable... | member |
package comparel
import (
"reflect"
"strconv"
"strings"
)
// DeepGreater 深度比较a的field字段的值是否大于b的field字段的值
func DeepGreater(a, b interface{}, field string) bool {
return deep(a, b, field, deepValueGreater)
}
// DeepLesser 深度比较a的field字段的值是否小于b的field字段的值
func DeepLesser(a, b interface{}, field string) bool {
return ... | non-member |
// Copyright 2016 The go-ethereum Authors
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License... | member |
package dialer
import (
"context"
"net"
"github.com/Dreamacro/clash/common/atomic"
"github.com/Dreamacro/clash/component/resolver"
)
var (
DefaultOptions []Option
DefaultInterface = atomic.NewTypedValue[string]("")
DefaultRoutingMark = atomic.NewInt32(0)
)
type NetDialer interface {
DialContext(ctx co... | non-member |
package pehape
import "testing"
func TestFunction(t *testing.T) {
tests := []struct {
name string
expected string
err error
num float64
opts []string
}{
{"1000", "1000", nil, 1000.12, nil},
{"error param > 4", "", errMust4Params, 1000.12, []string{"3", "4", "5", "5"}},
{"param 2 no... | non-member |
// Copyright 2023 <chaishushan{AT}gmail.com>. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package render
import (
"bytes"
"fmt"
"io"
"strings"
)
type SidebarTree []*SidebarItem
func (p SidebarTree) GenHTML(pageRoot string, pageInde... | non-member |
package units_test
import (
"encoding/json"
"time"
. "github.com/onsi/ginkgo"
. "github.com/onsi/ginkgo/extensions/table"
. "github.com/onsi/gomega"
"github.com/alext/heating-controller/units"
)
var _ = Describe("TimeOfDay", func() {
DescribeTable("constructing and forammting",
func(t units.TimeOfDay, exp... | non-member |
package client
import (
"bytes"
"github.com/hoffie/larasync/repository"
"github.com/hoffie/larasync/repository/nib"
)
// Downloader returns the downloader configured for the client
// and the passed ClientRepository.
func (c *Client) Downloader(r *repository.ClientRepository) *Downloader {
return &Downloader{
... | non-member |
package sqlite
import "database/sql"
// statementCreator allows to pass transaction or database to use in consumer.
type StatementCreator interface {
Prepare(query string) (*sql.Stmt, error)
}
| non-member |
// Copyright 2014 The Go Authors.
// See https://code.google.com/p/go/source/browse/CONTRIBUTORS
// Licensed under the same terms as Go itself:
// https://code.google.com/p/go/source/browse/LICENSE
// +build h2demo
package main
import (
"bytes"
"crypto/tls"
"flag"
"fmt"
"hash/crc32"
"image"
"image/jpeg"
"io"... | member |
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package webdav
import (
"fmt"
"net/http"
"os"
"reflect"
"sort"
"testing"
"golang.org/x/net/webdav/internal/xml"
)
func TestMemPS(t *testing.T) {
// c... | member |
package emails
import (
"os"
"os/signal"
"syscall"
"oott/helper"
)
type EmailScanner interface {
ScanEmails(domain string) ([]EmailDetails, error)
}
type EmailDetails struct {
Email string
Source string
}
// Cancel Sign handling
var cancel = make(chan struct{})
func InterruptHandler() {
// Create a chann... | non-member |
// Copyright 2014 The go-ethereum Authors
// This file is part of Webchain.
//
// Webchain is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any l... | non-member |
package minigo
const CacheSize = 16
type Cache struct {
curId int
maxId int
container [][]byte
}
func NewCache() *Cache {
return &Cache{
curId: 0,
container: make([][]byte, CacheSize),
}
}
func (c *Cache) Reset() {
c.curId = 0
c.maxId = -1
}
func (c *Cache) Add(msg []byte) {
if c.curId > c.... | non-member |
package cpu
import (
"fmt"
"os"
"runtime"
"testing"
"time"
)
func TestCpu_times(t *testing.T) {
v, err := Times(false)
if err != nil {
t.Errorf("error %v", err)
}
if len(v) == 0 {
t.Error("could not get CPUs ", err)
}
empty := TimesStat{}
for _, vv := range v {
if vv == empty {
t.Errorf("could no... | member |
// +build windows
package remote
import (
"errors"
"os"
)
func NewOutputInterceptor() OutputInterceptor {
return &outputInterceptor{}
}
type outputInterceptor struct {
intercepting bool
}
func (interceptor *outputInterceptor) StartInterceptingOutput() error {
if interceptor.intercepting {
return errors.New(... | member |
// Copyright 2017 Zack Guo <zack.y.guo@gmail.com>. All rights reserved.
// Use of this source code is governed by a MIT license that can
// be found in the LICENSE file.
package termui
import (
"image"
"os"
"sync"
tb "github.com/hawklithm/termbox-go"
)
type Drawable interface {
GetRect() image.Rectangle
SetRe... | member |
package database
import (
"bytes"
"context"
"strings"
"testing"
"go.mongodb.org/mongo-driver/bson"
)
func TestConnect(t *testing.T) {
db := Connect()
db.Faculty.Drop(context.TODO())
var documents []bson.D
db.Faculty.Decode(&documents)
assert(t, len(documents) == 0,
"Expected collection to be empty after... | non-member |
// This file is part of Gate.
// Copyright (C) 2012-2015 Cyril Adrian <cyril.adrian@gmail.com>
//
// Gate is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 3 of the License.
//
// Gate is distributed i... | non-member |
package storage
import (
"encoding/json"
"os"
"path/filepath"
"strings"
"syscall"
)
// Storage is an interface to interact with the storage
type Storage struct {
// Opts are the options for the storage
Opts StorageOptions
}
// StorageOptions are the options for the storage
type StorageOptions struct {
// Roo... | non-member |
package mongo
import (
"encoding/json"
"io"
"os"
"strings"
"time"
"github.com/johnwilson/bytengine"
"github.com/johnwilson/bytengine/bytestore"
"github.com/nu7hatch/gouuid"
"gopkg.in/mgo.v2"
)
type Config struct {
Addresses []string `json:"addresses"`
Timeout time.Duration `json:"timeout"`
... | member |
ICSE 2027 Heap Membership-Inference Dataset — Public Competition Release
This is the public competition release of the ICSE 2027 membership-inference benchmark for Go, Java, Python, Ruby, and Rust. It contains train and validation only.
The release contains 54,040 source-code files.
Loading the dataset
pip install datasets
Each programming language is a separate, case-sensitive configuration:
from datasets import load_dataset
python_data = load_dataset(
"Poisoned-Chalice/ICSE-2027-public",
"Python",
)
print(python_data)
# DatasetDict with train and validation only; no test split is published.
Load one public split:
python_validation = load_dataset(
"Poisoned-Chalice/ICSE-2027-public",
"Python",
split="validation",
)
Dataset structure
| Configuration | Train | Validation | Public total |
|---|---|---|---|
| Go | 10,000 | 1,000 | 11,000 |
| Java | 10,000 | 1,000 | 11,000 |
| Python | 10,000 | 1,000 | 11,000 |
| Ruby | 10,000 | 1,000 | 11,000 |
| Rust | 9,040 | 1,000 | 10,040 |
Every public split is exactly balanced between member and non-member. The 10,000-row training splits contain 5,000 files per label; Rust training contains 4,520 files per label. Every validation split contains 500 files per label.
Each row has two columns:
| Column | Type | Description |
|---|---|---|
content |
large_string |
Complete source-code file contents |
membership |
large_string |
The string member or non-member |
The language is represented by the configuration name. Repository paths, filenames, original repository identifiers, per-file license metadata, source duplicate annotations, and classifier predictions are not published.
Provenance and labels
The benchmark is derived from
The Heap. A file is a
member when it is marked as an exact duplicate in both Stack v1 and Stack v2.
A file is a non-member when its exact- and near-duplicate flags are false in
both versions. Null, ambiguous, and mixed cases are excluded.
The benchmark applies classifier-based hard-example selection and near-duplicate filtering before constructing balanced, content-disjoint splits. Exact private split parameters, the source revision, generation manifest, and hidden-test artifacts are deliberately excluded from this public repository to protect the competition.
These labels describe overlap with the Stack corpora; they do not prove that an arbitrary model was trained on a particular file.
Limitations and responsible use
- This is an intentionally difficult subset and is not an IID sample of The Heap, so results should not be interpreted as population-wide attack performance.
- Membership is a Stack-overlap proxy, not verified training membership for a particular model.
- The labels inherit the accuracy and limitations of the source duplicate annotations.
- Row-level repository provenance and license metadata are absent from the published schema.
The upstream The Heap dataset card declares GPL-3.0. Individual source files may remain subject to the copyright and license terms of their originating repositories. Treat all source code as untrusted text: do not execute samples without appropriate isolation and review.
This benchmark is intended for privacy, memorization, and membership-inference research. It should not be used to make claims about individual authors, establish code ownership, or infer that a deployed model used a specific file without additional evidence.
Removal requests concerning source material can be directed through The Heap opt-out process.
Citation
Please cite the source dataset:
@inproceedings{katzy2025heap,
author = {Jonathan Katzy and Razvan Mihai Popescu and
Arie van Deursen and Maliheh Izadi},
title = {The Heap: A Contamination-Free Multilingual Code Dataset
for Evaluating Large Language Models},
booktitle = {2025 IEEE/ACM Second International Conference on
AI Foundation Models and Software Engineering (Forge)},
year = {2025},
pages = {151--155},
doi = {10.1109/Forge66646.2025.00025}
}
- Downloads last month
- -