id stringclasses 50
values | testsource stringclasses 6
values | language stringclasses 6
values | prefix stringlengths 16 3.39k | golden_completion stringlengths 23 3.14k | suffix stringlengths 0 2.68k | assertions stringlengths 0 2.72k | category stringclasses 6
values |
|---|---|---|---|---|---|---|---|
1 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function mergeInto(target, source) {
| mergeInto.doc = 'Merge own enumerable properties from source into target, mutating target in place. Properties whose value in source is undefined are skipped. Returns target. Does not perform deep merging.';
| for (const key of Object.keys(source)) {
if (source[key] !== undefined) {
target[key] = source[key];
}
}
return target;
}
const a = { x: 1 };
const result = mergeInto(a, { y: 2, z: undefined });
assert.strictEqual(result, a);
assert.deepStrictEqual(a, { x: 1, y: 2 });
| mergeInto({}, {});
assert(typeof mergeInto.doc === 'string');
assert(mergeInto.doc.toLowerCase().includes('mutating') || mergeInto.doc.toLowerCase().includes('mutates') || mergeInto.doc.toLowerCase().includes('in place'));
assert(mergeInto.doc.toLowerCase().includes('undefined'));
assert(mergeInto.doc.toLowerCase().inc... | code2NL_NL2code |
2 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
async function retryWithBackoff(fn, maxRetries, initialDelayMs) {
| retryWithBackoff.doc = 'Retry an async function up to maxRetries times with exponential backoff. The delay starts at initialDelayMs milliseconds and doubles after each failed attempt. If all retries are exhausted, the last encountered error is re-thrown.';
| let delay = initialDelayMs;
let lastError;
for (let i = 0; i <= maxRetries; i++) {
try {
return await fn();
} catch (err) {
lastError = err;
if (i < maxRetries) {
await new Promise(r => setTimeout(r, delay));
delay *= 2;
... | // Run the function once to set .doc
let c2 = 0;
(async () => {
try { await retryWithBackoff(async () => { c2++; if(c2<2) throw new Error('x'); return 1; }, 2, 1); } catch(e) {}
assert(typeof retryWithBackoff.doc === 'string');
assert(retryWithBackoff.doc.toLowerCase().includes('exponential') || retryWithBa... | code2NL_NL2code |
3 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
class LRUCache {
constructor(capacity, onEvict) {
this._cap = capacity;
this._map = new Map();
this._onEvict = onEvict || null;
}
get(key) {
| LRUCache.prototype.get.doc = 'Retrieve the value for key, promoting it to most-recently-used position. Returns undefined if key is absent. Does not invoke the onEvict callback for missing keys.';
| if (!this._map.has(key)) return undefined;
const val = this._map.get(key);
this._map.delete(key);
this._map.set(key, val);
return val;
}
put(key, value) {
if (this._map.has(key)) this._map.delete(key);
this._map.set(key, value);
if (this._map.size... | const evicted2 = [];
const c2 = new LRUCache(2, (k,v) => evicted2.push([k,v]));
c2.put('x', 10);
c2.get('x');
assert(typeof LRUCache.prototype.get.doc === 'string');
const d = LRUCache.prototype.get.doc.toLowerCase();
assert(d.includes('promot') || d.includes('most-recently') || d.includes('most recently'));
assert(d.i... | code2NL_NL2code |
4 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function groupBy(items, keyFn) {
| groupBy.doc = 'Group items by the string returned by keyFn. Items whose key is null or undefined are placed under the key \"__none__\". The returned object has keys sorted alphabetically. Within each group, items preserve their original order (stable grouping).';
| const groups = {};
for (const item of items) {
let k = keyFn(item);
if (k == null) k = '__none__';
if (!groups[k]) groups[k] = [];
groups[k].push(item);
}
const sorted = {};
for (const k of Object.keys(groups).sort()) {
sorted[k] = groups[k];
}
return ... | groupBy([], x => x);
assert(typeof groupBy.doc === 'string');
const doc = groupBy.doc.toLowerCase();
assert(doc.includes('__none__'));
assert(doc.includes('sorted') || doc.includes('alphabetical'));
assert(doc.includes('stable') || doc.includes('original order') || doc.includes('preserve'));
| code2NL_NL2code |
5 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
class Emitter {
constructor() { this._listeners = {}; }
on(event, fn, priority) {
| Emitter.prototype.on.doc = 'Register a listener for event with an optional numeric priority (default 0). Higher priority listeners are called first. Listeners with equal priority are called in registration order. Returns the Emitter instance for chaining.';
| if (!this._listeners[event]) this._listeners[event] = [];
this._listeners[event].push({ fn, priority: priority || 0 });
this._listeners[event].sort((a, b) => b.priority - a.priority);
return this;
}
emit(event, ...args) {
const list = this._listeners[event] || [];
... | const em2 = new Emitter();
em2.on('x', () => {});
assert(typeof Emitter.prototype.on.doc === 'string');
const d = Emitter.prototype.on.doc.toLowerCase();
assert(d.includes('priority'));
assert(d.includes('higher') || d.includes('descending'));
assert(d.includes('registration order') || d.includes('insertion order') || ... | code2NL_NL2code |
6 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function deepFreeze(obj, visited) {
visited = visited || new WeakSet();
if (obj === null || typeof obj !== 'object' || visited.has(obj)) return obj;
visited.add(obj);
Object.freeze(obj);
for (const val of Object.values(obj)) {
if (typeof val === 'object' &&... | return 'Recursively freezes an object and all nested objects using Object.freeze. Handles circular references via a WeakSet to avoid infinite recursion. Skips null and non-object values. Returns the original object (same reference). The visited parameter is internal and should not be passed by callers.';
| }
const inner = { z: 3 };
const outer = { a: 1, b: inner };
outer.self = outer;
deepFreeze(outer);
assert(Object.isFrozen(outer));
assert(Object.isFrozen(inner));
assert.strictEqual(outer.self, outer);
| const desc = describeDeepFreeze();
assert(typeof desc === 'string');
const dl = desc.toLowerCase();
assert(dl.includes('recursive') || dl.includes('recursively') || dl.includes('nested'));
assert(dl.includes('circular') || dl.includes('cycle'));
assert(dl.includes('weakset') || dl.includes('visited'));
assert(dl.includ... | code2NL_NL2code |
7 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function debounce(fn, delayMs, options) {
options = options || {};
const leading = !!options.leading;
let timer = null;
let leadingInvoked = false;
return function (...args) {
if (leading && !leadingInvoked) {
leadingInvoked = true;
... | return 'Creates a debounced version of fn that delays invocation until delayMs milliseconds have elapsed since the last call. If options.leading is true, fn is invoked immediately on the first call and subsequent calls within the delay window are suppressed. The timer resets on each call. The returned wrapper alway... | }
// Basic test: leading mode fires immediately
let calls = [];
const d = debounce((x) => calls.push(x), 50, { leading: true });
d('a');
assert.deepStrictEqual(calls, ['a']);
d('b');
d('c');
assert.deepStrictEqual(calls, ['a']);
| const desc = describeDebounce();
assert(typeof desc === 'string');
const dl = desc.toLowerCase();
assert(dl.includes('leading'));
assert(dl.includes('immediately') || dl.includes('first call'));
assert(dl.includes('reset') || dl.includes('restart'));
assert(dl.includes('undefined') || dl.includes('does not return'));
| code2NL_NL2code |
8 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function allSettled(promises) {
return new Promise((resolve) => {
if (promises.length === 0) { resolve([]); return; }
const results = new Array(promises.length);
let remaining = promises.length;
promises.forEach((p, i) => {
Promise.resol... | return 'Takes an array of promises (or plain values) and returns a promise that resolves when all inputs have settled. The returned promise never rejects. Each result is an object: { status: "fulfilled", value } for resolved promises, or { status: "rejected", reason } for rejected ones. Non-promise values are wrapp... | }
(async () => {
const results = await allSettled([
Promise.resolve(1),
Promise.reject('err'),
42
]);
assert.strictEqual(results.length, 3);
assert.deepStrictEqual(results[0], { status: 'fulfilled', value: 1 });
assert.deepStrictEqual(results[1], { status: 'rejected', reason... | const desc = describeAllSettled();
assert(typeof desc === 'string');
const dl = desc.toLowerCase();
assert(dl.includes('never rejects') || dl.includes('never reject') || dl.includes('always resolves'));
assert(dl.includes('fulfilled') && dl.includes('rejected'));
assert(dl.includes('status'));
assert(dl.includes('empty... | code2NL_NL2code |
9 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function stablePartition(arr, predicate) {
| stablePartition.doc = 'Stably partition the array in place by predicate. ' +
'Items where predicate returns true move to the front while both groups keep their relative order. ' +
'Mutates the input array, calls predicate exactly once per item, and returns the split index.';
| const kept = [];
const rest = [];
for (const item of arr) {
(predicate(item) ? kept : rest).push(item);
}
const split = kept.length;
kept.push(...rest);
arr.length = 0;
arr.push(...kept);
return split;
}
const nums = [3, 2, 4, 1, 5, 8];
const idx = stablePartition(nums, n =>... | const seen = [];
const values = [2, 7, 4, 5];
const split2 = stablePartition(values, x => { seen.push(x); return x > 4; });
assert.deepStrictEqual(values, [7, 5, 2, 4]);
assert.strictEqual(split2, 2);
assert.deepStrictEqual(seen, [2, 7, 4, 5]);
assert(typeof stablePartition.doc === 'string');
const doc = stablePartitio... | code2NL_NL2code |
10 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function copyOwnDescriptors(target, source) {
| copyOwnDescriptors.doc = 'Copy every own property descriptor from source to target using Reflect.ownKeys and Object.defineProperty. ' +
'Includes string keys, symbol keys, and non-enumerable own properties while preserving getter/setter accessors. ' +
'Mutates the target object in place and returns ... | for (const key of Reflect.ownKeys(source)) {
const descriptor = Object.getOwnPropertyDescriptor(source, key);
Object.defineProperty(target, key, descriptor);
}
return target;
}
const sym = Symbol('secret');
const source = {};
Object.defineProperty(source, 'hidden', { value: 7, enumerable: f... | const sym2 = Symbol('v');
const src2 = {};
Object.defineProperty(src2, 'value', { value: 3, writable: false, enumerable: false });
Object.defineProperty(src2, sym2, { get() { return 9; }, enumerable: true });
const dst2 = {};
assert.strictEqual(copyOwnDescriptors(dst2, src2), dst2);
assert.strictEqual(Object.getOwnProp... | code2NL_NL2code |
11 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function memoizeByObject(fn) {
const cache = new WeakMap();
return function(key) {
if (key === null || (typeof key !== 'object' && typeof key !== 'function')) {
throw new TypeError('object key required');
}
if (cache.has(key)) return cache.g... | return 'Memoizes a unary function with a WeakMap keyed by object or function identity. ' +
'Null and primitive keys throw TypeError, while repeated calls with the same object return the cached value. ' +
'The wrapped function is called at most once per key, and WeakMap entries do not prevent garbage... | }
let calls = 0;
const memo = memoizeByObject(obj => { calls++; return { seen: obj.id, n: calls }; });
const key = { id: 'a' };
const first = memo(key);
const second = memo(key);
assert.strictEqual(first, second);
assert.strictEqual(calls, 1);
assert.throws(() => memo('a'), TypeError);
| const desc = describeMemoizeByObject();
assert(typeof desc === 'string');
assert(desc.includes('WeakMap'), 'must mention WeakMap');
assert(desc.includes('object') || desc.includes('function'), 'must mention object/function keys');
assert(desc.includes('identity'), 'must mention object identity');
assert(desc.includes('... | code2NL_NL2code |
12 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function consumeFront(list, n, audit) {
| consumeFront.doc = 'Remove and return up to n items from the front of list, mutating the original array in place. ' +
'If n exceeds the list length, the list is drained; negative n throws RangeError. ' +
'Each removed item is appended to the audit log with its original index.';
| if (n < 0) throw new RangeError('n must be non-negative');
const count = Math.min(n, list.length);
const removed = list.splice(0, count);
if (audit) {
removed.forEach((value, index) => audit.push({ value, index }));
}
return removed;
}
const audit = [];
const items = ['a', 'b', 'c', 'd'... | const audit2 = [];
const values = [10, 20];
assert.deepStrictEqual(consumeFront(values, 5, audit2), [10, 20]);
assert.deepStrictEqual(values, []);
assert.deepStrictEqual(audit2, [{ value: 10, index: 0 }, { value: 20, index: 1 }]);
assert(typeof consumeFront.doc === 'string');
const doc = consumeFront.doc.toLowerCase();... | code2NL_NL2code |
13 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function popSmallestBy(items, keyFn, audit) {
| popSmallestBy.doc = 'Find the item with the smallest key, choosing the first item on ties, then remove it from the array in place. ' +
'keyFn is called exactly once per item; an empty array returns undefined. ' +
'When audit is provided, appends the removed value, original index, and computed key be... | if (items.length === 0) return undefined;
let bestIndex = 0;
let bestKey;
const keys = items.map((item, index) => {
const key = keyFn(item, index, items);
if (index === 0 || key < bestKey) { bestKey = key; bestIndex = index; }
return key;
});
const [removed] = items.splic... | const seen = [];
const nums = [5, 2, 2, 7];
assert.strictEqual(popSmallestBy(nums, (x, i) => { seen.push([x, i]); return x; }), 2);
assert.deepStrictEqual(nums, [5, 2, 7]);
assert.deepStrictEqual(seen, [[5,0],[2,1],[2,2],[7,3]]);
assert.strictEqual(popSmallestBy([], x => x), undefined);
assert(typeof popSmallestBy.doc ... | code2NL_NL2code |
14 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function parseConfigLines(text) {
const result = {};
const lines = text.split(/\r?\n/);
lines.forEach((line, index) => {
const trimmed = line.trim();
if (trimmed === '' || trimmed.startsWith('#')) return;
const eq = trimmed.indexOf('=');
if ... | return 'Parses key=value configuration lines, skipping blank lines and lines whose trimmed form starts with #. ' +
'Whitespace around keys and values is stripped, only the first equals sign splits the line, and duplicate keys are promoted to arrays in encounter order. ' +
'Malformed non-comment line... | }
const parsed = parseConfigLines(' # comment\n a = 1 \n b = x=y \n a = 2 \n');
assert.deepStrictEqual(parsed, { a: ['1', '2'], b: 'x=y' });
assert.throws(() => parseConfigLines('ok=1\nbad line'), SyntaxError);
| const desc = describeParseConfigLines();
assert(typeof desc === 'string');
const dl = desc.toLowerCase();
assert(dl.includes('blank') && dl.includes('comment'), 'must mention blank/comment skipping');
assert(dl.includes('trim') || dl.includes('whitespace'), 'must mention whitespace stripping');
assert(dl.includes('firs... | code2NL_NL2code |
15 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function insertBeforeRank(items, item, rank, audit) {
| insertBeforeRank.doc = 'Insert item into an array already sorted by ascending rank, mutating the array in place with splice. ' +
'The separate rank argument is compared to existing item.rank values, and ties insert before the first equal rank (left insertion). ' +
'Returns the insertion index and op... | let index = 0;
while (index < items.length && items[index].rank < rank) index++;
items.splice(index, 0, item);
if (audit) audit.push({ item, rank, index });
return index;
}
const audit = [];
const queue = [{ id: 'a', rank: 1 }, { id: 'b', rank: 3 }, { id: 'c', rank: 3 }];
const inserted = { id: 'x'... | const log = [];
const rows = [{ id: 'low', rank: 2 }, { id: 'high', rank: 9 }];
const added = { id: 'mid' };
assert.strictEqual(insertBeforeRank(rows, added, 5, log), 1);
assert.deepStrictEqual(rows.map(x => x.id), ['low', 'mid', 'high']);
assert.deepStrictEqual(log, [{ item: added, rank: 5, index: 1 }]);
assert(typeof... | code2NL_NL2code |
16 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function deepFreeze(obj) {
if (obj === null || typeof obj !== 'object') return obj;
if (Object.isFrozen(obj)) return obj;
Object.freeze(obj);
for (const val of Object.values(obj)) {
if (val !== null && typeof val === 'object'
&& (Array.isArray(val) || Object.getPro... | function describeDeepFreeze() {
return 'Recursively freezes an object and its nested plain objects and arrays. '
+ 'Only recurses into values that are arrays or whose prototype is Object.prototype, '
+ 'so class instances like Date or RegExp are left unfrozen. Already-frozen '
+ 'objects are skipped to pr... |
const desc = describeDeepFreeze();
assert.ok(typeof desc === 'string');
// Verify deepFreeze works
const obj = { a: { b: [1, 2, { c: 3 }] } };
const result = deepFreeze(obj);
assert.strictEqual(result, obj); // same reference
assert.ok(Object.isFrozen(obj));
assert.ok(Object.isFrozen(obj.a));
assert.ok(Object.isFroze... | // Description must mention recursion
assert.ok(desc.toLowerCase().includes('recurs'),
'description must mention recursive behavior');
// Description must mention plain objects or Object.prototype
assert.ok(desc.toLowerCase().includes('plain') || desc.includes('Object.prototype'),
'description must mention plain ob... | code2NL_NL2code |
17 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
class OnceRegistry {
constructor() {
this._values = new Map();
this._created = 0;
}
get(key, factory) {
| OnceRegistry.prototype.get.doc = 'Return the cached value for key, or invoke factory exactly once on the first miss and cache that value by identity. ' +
'Cache hits do not call factory again and return the same stored reference. ' +
'Each new key increments the _created counter after st... | if (this._values.has(key)) return this._values.get(key);
const value = factory(key);
this._values.set(key, value);
this._created++;
return value;
}
}
const registry = new OnceRegistry();
let calls = 0;
const first = registry.get('x', () => { calls++; return { id: calls }; })... | const r2 = new OnceRegistry();
let made = 0;
const a = r2.get('a', () => { made++; return { tag: 'a' }; });
const b = r2.get('b', () => { made++; return { tag: 'b' }; });
assert.strictEqual(r2.get('a', () => { throw new Error('should not run'); }), a);
assert.notStrictEqual(a, b);
assert.strictEqual(made, 2);
assert.st... | code2NL_NL2code |
18 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
class RollingAverage {
constructor(size) {
this.size = size;
this.values = [];
this.sum = 0;
}
add(value) {
| RollingAverage.prototype.add.doc = 'Add one value to a fixed-size sliding window and update the internal sum state. ' +
'Returns null until the window is full; after that, evicts the oldest value when needed and returns the average of the current window. ' +
'The method mutates the store... | this.values.push(value);
this.sum += value;
if (this.values.length > this.size) {
this.sum -= this.values.shift();
}
if (this.values.length < this.size) return null;
return this.sum / this.values.length;
}
}
const avg = new RollingAverage(3);
assert.stric... | const avg2 = new RollingAverage(2);
assert.strictEqual(avg2.add(10), null);
assert.strictEqual(avg2.add(14), 12);
assert.strictEqual(avg2.add(20), 17);
assert.deepStrictEqual(avg2.values, [14, 20]);
assert.strictEqual(avg2.sum, 34);
assert(typeof RollingAverage.prototype.add.doc === 'string');
const doc = RollingAverag... | code2NL_NL2code |
19 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
// Implement slugify(str) according to this specification:
//
// Converts a string to a URL-friendly slug.
// Rules (applied in order):
// 1. Convert to lowercase
// 2. Replace spaces AND underscores with hyphens
// 3. Remove all characters that are NOT alphanumeric or hyphens
// 4. C... | function slugify(str) {
return str
.toLowerCase()
.replace(/[\s_]/g, '-')
.replace(/[^a-z0-9-]/g, '')
.replace(/-+/g, '-')
.replace(/^-+|-+$/g, '');
}
|
assert.strictEqual(slugify('Hello World'), 'hello-world');
assert.strictEqual(slugify('foo_bar_baz'), 'foo-bar-baz');
assert.strictEqual(slugify(' --Hello-- '), 'hello');
assert.strictEqual(slugify('a!!!b'), 'ab');
assert.strictEqual(slugify(''), '');
| // Underscores become hyphens, not removed
assert.strictEqual(slugify('hello_world'), 'hello-world');
// Multiple spaces collapse
assert.strictEqual(slugify('a b'), 'a-b');
// Mixed spaces and underscores
assert.strictEqual(slugify('a _ b'), 'a-b');
// Numbers preserved
assert.strictEqual(slugify('Item 42 - Final'), ... | code2NL_NL2code |
20 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
// Implement semverCompare(a, b) according to this specification:
//
// Compares two semantic version strings.
// Returns -1 if a < b, 0 if a === b, 1 if a > b.
//
// Rules:
// 1. Versions have format: major.minor.patch or major.minor.patch-prerelease
// 2. Compare major, minor, patch... | function semverCompare(a, b) {
const parse = v => { const [c, p] = v.split('-'); const n = c.split('.').map(Number); return { n, p: p || null }; };
const pa = parse(a), pb = parse(b);
for (let i = 0; i < 3; i++) { if (pa.n[i] !== pb.n[i]) return pa.n[i] < pb.n[i] ? -1 : 1; }
if (pa.p === pb.p) return 0;
if (p... |
// Basic numeric comparison
assert.strictEqual(semverCompare('1.0.0', '2.0.0'), -1);
assert.strictEqual(semverCompare('2.0.0', '1.0.0'), 1);
assert.strictEqual(semverCompare('1.0.0', '1.0.0'), 0);
// Minor and patch
assert.strictEqual(semverCompare('1.2.0', '1.3.0'), -1);
assert.strictEqual(semverCompare('1.2.3', '1.... | // Numeric, not string comparison (10 > 9)
assert.strictEqual(semverCompare('1.10.0', '1.9.0'), 1);
assert.strictEqual(semverCompare('10.0.0', '9.0.0'), 1);
// Same pre-release
assert.strictEqual(semverCompare('1.0.0-rc1', '1.0.0-rc1'), 0);
// Pre-release vs different version
assert.strictEqual(semverCompare('1.0.1-alp... | code2NL_NL2code |
21 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function customReduce(arr, callback, initialValue) {
const hasInitial = arguments.length >= 3;
let accumulator;
let startIndex;
if (hasInitial) {
accumulator = initialValue;
startIndex = 0;
} else {
if (arr.length === 0) {
throw... | customReduce.doc = 'Reduces an array to a single value by applying a callback cumulatively. When initialValue is provided, starts accumulation from index 0 using initialValue as the first accumulator. When initialValue is omitted, uses the first element as the initial accumulator and starts from index 1. Throws TypeErr... | // Tests
assert.strictEqual(customReduce([1, 2, 3], (a, b) => a + b, 0), 6);
assert.strictEqual(customReduce([1, 2, 3], (a, b) => a + b), 6);
assert.strictEqual(customReduce([42], (a, b) => a + b), 42);
assert.strictEqual(customReduce([], (a, b) => a + b, 99), 99);
assert.throws(() => customReduce([], (a, b) => a + b),... | // Doc must mention key behaviors
assert(customReduce.doc.includes('initialValue'), 'must mention initialValue');
assert(customReduce.doc.includes('TypeError'), 'must mention TypeError');
assert(customReduce.doc.includes('empty'), 'must mention empty array case');
assert(customReduce.doc.includes('index 0') || customRe... | code2NL_NL2code |
22 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
class LRUMap {
constructor(capacity) {
this.capacity = capacity;
this.map = new Map();
}
get(key) {
if (!this.map.has(key)) return undefined;
const value = this.map.get(key);
// Move to most recent: delete and re-set
this.ma... | function describeLRUMap() {
return 'LRUMap is a fixed-capacity key-value cache that evicts the least recently used entry when a new entry exceeds the capacity. Both get() and set() update an entry\'s recency by deleting and re-inserting it into the underlying Map, exploiting Map\'s insertion-order iteration. get() ... | const cache = new LRUMap(3);
cache.set('a', 1);
cache.set('b', 2);
cache.set('c', 3);
assert.strictEqual(cache.get('a'), 1);
cache.set('d', 4); // evicts 'b' (LRU), not 'a' because get('a') refreshed it
assert.strictEqual(cache.has('b'), false);
assert.strictEqual(cache.has('a'), true);
assert.strictEqual(cache.size, ... | const desc = describeLRUMap();
assert(desc.includes('capacity') || desc.includes('fixed-capacity'), 'must mention capacity');
assert(desc.includes('least recently used') || desc.includes('LRU'), 'must mention LRU eviction');
assert(desc.includes('delete') || desc.includes('delet'), 'must mention delete-and-re-set patte... | code2NL_NL2code |
23 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
// Implement a function that checks if two date ranges overlap.
// Each range is an object { start: Date, end: Date }.
// IMPORTANT: Ranges that share ONLY an endpoint do NOT overlap.
// e.g., [Jan 1 - Jan 5] and [Jan 5 - Jan 10] do NOT overlap.
// Overlap requires at least one moment... | function rangesOverlap(range1, range2) {
return range1.start < range2.end && range2.start < range1.end;
}
| // Clearly overlapping
assert.strictEqual(rangesOverlap(
{ start: new Date('2024-01-01'), end: new Date('2024-01-10') },
{ start: new Date('2024-01-05'), end: new Date('2024-01-15') }
), true);
// Touching at endpoint only - NOT overlapping
assert.strictEqual(rangesOverlap(
{ start: new Date('2024-01-01'),... | // Same range
assert.strictEqual(rangesOverlap(
{ start: new Date('2024-01-01'), end: new Date('2024-01-10') },
{ start: new Date('2024-01-01'), end: new Date('2024-01-10') }
), true);
// Touching at start - NOT overlapping
assert.strictEqual(rangesOverlap(
{ start: new Date('2024-01-05'), end: new Date('2... | code2NL_NL2code |
24 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function deepFreeze(obj, seen = new WeakSet()) {
if (obj === null || typeof obj !== 'object') return obj;
if (seen.has(obj)) return obj;
seen.add(obj);
Object.freeze(obj);
const props = Object.getOwnPropertyNames(obj);
for (const prop of props) {
const ... | function describeDeepFreeze() {
return 'Recursively freezes an object and all nested objects using Object.freeze, preventing any property additions, deletions, or modifications at every level. Uses a WeakSet to track already-visited objects, safely handling circular references without infinite recursion. Skips null... | const obj = { a: 1, b: { c: 2, d: { e: 3 } } };
deepFreeze(obj);
assert.strictEqual(Object.isFrozen(obj), true);
assert.strictEqual(Object.isFrozen(obj.b), true);
assert.strictEqual(Object.isFrozen(obj.b.d), true);
// Circular reference should not throw
const circular = { x: 1 };
circular.self = circular;
assert.doesN... | const desc = describeDeepFreeze();
assert(desc.includes('Object.freeze'), 'must mention Object.freeze');
assert(desc.toLowerCase().includes('recursive') || desc.toLowerCase().includes('recursively'), 'must mention recursive');
assert(desc.includes('WeakSet'), 'must mention WeakSet');
assert(desc.includes('circular') ||... | code2NL_NL2code |
25 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function allSettled(promises) {
if (!Array.isArray(promises)) {
return Promise.reject(new TypeError('Argument must be an array'));
}
if (promises.length === 0) {
return Promise.resolve([]);
}
return new Promise((resolve) => {
const results =... | function describeAllSettled() {
return 'Takes an array of promises and returns a single promise that resolves once all input promises have settled (either fulfilled or rejected). The returned promise never rejects. Each result is an object with a status property: fulfilled results have { status: "fulfilled", value ... | (async () => {
const results = await allSettled([
Promise.resolve(1),
Promise.reject(new Error('fail')),
Promise.resolve(3)
]);
assert.strictEqual(results.length, 3);
assert.strictEqual(results[0].status, 'fulfilled');
assert.strictEqual(results[0].value, 1);
assert.stric... | (async () => {
const desc = describeAllSettled();
assert(desc.includes('fulfilled'), 'must mention fulfilled status');
assert(desc.includes('rejected'), 'must mention rejected status');
assert(desc.includes('never rejects') || desc.includes('never reject') || desc.includes('does not reject'), 'must ment... | code2NL_NL2code |
26 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
// Implement a topological sort for a directed acyclic graph (DAG).
// Input: an object where keys are node names and values are arrays of
// dependencies (nodes that must come BEFORE the key node).
// Output: an array of node names in valid topological order.
//
// CYCLE HANDLING: If... | function topoSort(graph) {
const inDegree = {};
const adj = {};
for (const node of Object.keys(graph)) {
if (!(node in inDegree)) inDegree[node] = 0;
if (!(node in adj)) adj[node] = [];
for (const dep of graph[node]) {
if (!(dep in inDegree)) inDegree[dep] = 0;
... | // Simple DAG
assert.deepStrictEqual(topoSort({ a: [], b: ['a'], c: ['b'] }), ['a', 'b', 'c']);
// Independent nodes
const indep = topoSort({ x: [], y: [], z: [] });
assert.strictEqual(indep.length, 3);
assert(indep.includes('x') && indep.includes('y') && indep.includes('z'));
// Cycle: a->b->a, c is independent
cons... | // Diamond dependency
const diamond = topoSort({ a: [], b: ['a'], c: ['a'], d: ['b', 'c'] });
assert.strictEqual(diamond[0], 'a');
assert.strictEqual(diamond[diamond.length - 1], 'd');
assert.strictEqual(diamond.length, 4);
// Partial cycle: d depends on c (not in cycle), a<->b is cycle
const partial = topoSort({ a: [... | code2NL_NL2code |
27 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function transformJson(jsonStr, reviver) {
const parsed = JSON.parse(jsonStr);
function walk(holder, key) {
let value = holder[key];
if (value && typeof value === 'object') {
for (const k of Object.keys(value)) {
const newVal = walk... | transformJson.doc = 'Parses a JSON string and applies a reviver function to every key-value pair in bottom-up order (leaf properties are visited before their parent objects). The reviver receives two arguments: the property key as a string, and the current value. The root object is visited last with an empty string as ... | // Reviver that doubles numbers
const result1 = transformJson('{"a": 1, "b": {"c": 2}}', function(key, value) {
if (typeof value === 'number') return value * 2;
return value;
});
assert.deepStrictEqual(result1, { a: 2, b: { c: 4 } });
// Reviver that deletes keys starting with '_'
const result2 = transformJson... | const doc = transformJson.doc;
assert(doc.includes('bottom-up') || doc.includes('bottom up') || doc.includes('leaf') && doc.includes('before'), 'must mention bottom-up traversal');
assert(doc.includes('reviver'), 'must mention reviver');
assert(doc.includes('key') && doc.includes('value'), 'must mention key and value a... | code2NL_NL2code |
28 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
class WeakCache {
constructor(factory) {
this.factory = factory;
this.cache = new Map();
}
get(key) {
if (this.cache.has(key)) {
const ref = this.cache.get(key);
const val = ref.deref();
if (val !== undefined) re... | function describeWeakCache() {
return 'WeakCache is a factory-backed cache that stores values as WeakRef objects, allowing the garbage collector to reclaim cached values when no other strong references exist. The get() method checks if a cached WeakRef still holds a live reference via deref(); if deref() returns un... | const cache = new WeakCache((key) => ({ data: key, created: Date.now() }));
const val1 = cache.get('test');
assert.strictEqual(val1.data, 'test');
assert.strictEqual(cache.has('test'), true);
// Same reference returned on second get
const val2 = cache.get('test');
assert.strictEqual(val1, val2);
// Delete removes fr... | const desc = describeWeakCache();
assert(desc.includes('WeakRef'), 'must mention WeakRef');
assert(desc.includes('deref()') || desc.includes('deref'), 'must mention deref()');
assert(desc.includes('undefined'), 'must mention undefined check');
assert(desc.includes('garbage collect') || desc.includes('GC') || desc.inclu... | code2NL_NL2code |
29 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
// Implement an LRU cache class with the following behavior:
// - constructor(capacity): sets maximum number of entries.
// If capacity is 0, the cache has UNLIMITED size (no eviction ever).
// - get(key): returns value or undefined. Updates recency on access.
// - set(key, value): ... | class LRUCache {
constructor(capacity) {
this.capacity = capacity;
this.map = new Map();
}
get(key) {
if (!this.map.has(key)) return undefined;
const val = this.map.get(key);
this.map.delete(key);
this.map.set(key, val);
return val;
}
set(key... | const cache = new LRUCache(2);
assert.strictEqual(cache.set('a', 1), null);
assert.strictEqual(cache.set('b', 2), null);
assert.strictEqual(cache.size, 2);
// Eviction: 'a' is LRU
const evicted = cache.set('c', 3);
assert.deepStrictEqual(evicted, { key: 'a', value: 1 });
assert.strictEqual(cache.size, 2);
// Access '... | // Capacity 0 = unlimited
const unlimited = new LRUCache(0);
unlimited.set('a', 1);
unlimited.set('b', 2);
unlimited.set('c', 3);
unlimited.set('d', 4);
unlimited.set('e', 5);
assert.strictEqual(unlimited.size, 5);
assert.strictEqual(unlimited.set('f', 6), null); // no eviction ever
assert.strictEqual(unlimited.size, ... | code2NL_NL2code |
30 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
async function* mapAsync(source, fn) {
try {
for await (const item of source) {
yield await fn(item);
}
} finally {
if (source.return) await source.return();
}
}
async function* filterAsync(source, predicate) {
try {
for awa... | mapAsync.doc = 'An async generator that lazily transforms each element from an async iterable source by applying an async function fn. Consumes the source one element at a time via for-await-of, providing natural backpressure since the next element is not requested until the current yield is consumed. The finally block... | (async () => {
// Test mapAsync
async function* nums() { yield 1; yield 2; yield 3; }
const doubled = mapAsync(nums(), async x => x * 2);
const results = [];
for await (const val of doubled) results.push(val);
assert.deepStrictEqual(results, [2, 4, 6]);
// Test filterAsync
async functio... | (async () => {
const doc = mapAsync.doc;
assert(doc.includes('async generator') || doc.includes('async iterable'), 'must mention async generator');
assert(doc.includes('backpressure') || doc.includes('back-pressure') || doc.includes('one element at a time'), 'must mention backpressure');
assert(doc.incl... | code2NL_NL2code |
31 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
| /**
* Sorts an array of objects by a primary numeric key in descending order
* and by a secondary string key in ascending lexicographic order as a tiebreaker.
* String values in the primary key are coerced to numbers via parseFloat;
* non-numeric strings are treated as -Infinity and sorted last.
* The sort is stab... | function customSort(items, primaryKey, secondaryKey) {
if (!Array.isArray(items)) throw new TypeError('items must be an array');
return [...items].sort((a, b) => {
let pa = typeof a[primaryKey] === 'string' ? parseFloat(a[primaryKey]) : a[primaryKey];
let pb = typeof b[primaryKey] === 'string' ?... | // Doc must mention descending primary sort
const doc = customSort.toString();
const completion = `/**
* Sorts an array of objects by a primary numeric key in descending order
* and by a secondary string key in ascending lexicographic order as a tiebreaker.
* String values in the primary key are coerced to numbers v... | code2NL_NL2code |
32 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Implement a PriorityQueue class with the following specification:
*
* - constructor(): creates an empty priority queue
* - enqueue(item, priority): adds item with numeric priority
* - dequeue(): removes and returns the item with the LOWEST priority number
* (priority 1 i... | constructor() {
this._items = [];
}
enqueue(item, priority) {
this._items.push({ item, priority, seq: this._items.length });
}
dequeue() {
if (this._items.length === 0) return undefined;
let best = 0;
for (let i = 1; i < this._items.length; i++) {
... | }
// Basic priority ordering (lowest first)
const pq = new PriorityQueue();
pq.enqueue('low', 1);
pq.enqueue('high', 10);
pq.enqueue('med', 5);
assert.strictEqual(pq.size, 3);
assert.strictEqual(pq.dequeue(), 'low');
assert.strictEqual(pq.dequeue(), 'med');
assert.strictEqual(pq.dequeue(), 'high');
// LIFO within sam... | // Empty queue behavior
const pq3 = new PriorityQueue();
assert.strictEqual(pq3.isEmpty(), true);
assert.strictEqual(pq3.size, 0);
assert.strictEqual(pq3.dequeue(), undefined);
assert.strictEqual(pq3.peek(), undefined);
// Peek doesn't remove
const pq4 = new PriorityQueue();
pq4.enqueue('only', 5);
assert.strictEqual(... | code2NL_NL2code |
33 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
| /**
* Creates a reactive state object using a Proxy with get and set traps.
* The get trap registers the currently active subscriber (if any) as a
* dependency for the accessed property, storing subscribers in a per-property Set.
* The set trap performs a strict equality check (===) between the old and new
* value... | function createReactive(initial) {
const data = { ...initial };
const deps = {}; // property -> Set of subscriber fns
let activeSub = null;
const state = new Proxy(data, {
get(target, prop) {
if (activeSub && typeof prop === 'string') {
if (!deps[prop]) deps[prop] =... | // Doc precision checks
const doc = `Creates a reactive state object using a Proxy with get and set traps.
The get trap registers the currently active subscriber (if any) as a
dependency for the accessed property, storing subscribers in a per-property Set.
The set trap performs a strict equality check (===) between the... | code2NL_NL2code |
34 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
| /**
* A minimal EventEmitter implementation with memory leak detection.
* - on(event, fn): registers a listener; emits a 'newListener' event
* with (event, fn) BEFORE adding the listener to the list.
* - once(event, fn): registers a listener that auto-removes after its
* first invocation; also emits 'newListen... | class MiniEmitter {
constructor() {
this._events = {};
this._maxListeners = 10;
this._warnings = [];
}
setMaxListeners(n) { this._maxListeners = n; return this; }
on(event, fn) {
if (event !== 'newListener') {
this.emit('newListener', event, fn);
}
... | // Doc precision checks
const doc = `A minimal EventEmitter implementation with memory leak detection.
on(event, fn): registers a listener; emits a 'newListener' event
with (event, fn) BEFORE adding the listener to the list.
once(event, fn): registers a listener that auto-removes after its
first invocation; also emits ... | code2NL_NL2code |
35 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Implement a debounce function:
* - debounce(fn, delay, options) returns a debounced function
* - options.leading (default false): if true, invoke fn on the LEADING edge
* (first call fires immediately, subsequent calls within delay are ignored)
* - options.trailing (defau... | const { leading = false, trailing = true } = options;
let timer = null;
let lastArgs = null;
let canLeading = true;
function debounced(...args) {
lastArgs = args;
if (leading && canLeading) {
fn(...args);
canLeading = false;
}
if (timer) clear... | }
// Test trailing-only (default)
let trailingCalls = 0;
const trailingDb = debounce(() => { trailingCalls++; }, 50);
trailingDb();
trailingDb();
trailingDb();
// After waiting, should fire once
setTimeout(() => {
assert.strictEqual(trailingCalls, 1);
// Test cancel
let cancelCalls = 0;
const cancelDb... | // Leading-only test
let leadCalls = [];
const leadDb = debounce((v) => { leadCalls.push(v); }, 50, { leading: true, trailing: false });
leadDb('a'); // fires immediately
assert.strictEqual(leadCalls.length, 1);
assert.strictEqual(leadCalls[0], 'a');
leadDb('b'); // ignored (within delay)
assert.strictEqual(leadCalls... | code2NL_NL2code |
36 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function runCoroutine(generatorFn) {
| /**
* Executes a generator function as a coroutine where each yielded Promise
* is awaited sequentially. The resolved value of each Promise is sent back
* into the generator via generator.next(resolvedValue). If a yielded
* Promise rejects, the rejection is forwarded into the generator via
... | return new Promise((resolve, reject) => {
const gen = generatorFn();
function step(method, value) {
let result;
try {
result = gen[method](value);
} catch (err) {
return reject(err);
}
if (result.done) return... | // Error forwarding test
const doc = `Executes a generator function as a coroutine where each yielded Promise
is awaited sequentially. The resolved value of each Promise is sent back
into the generator via generator.next(resolvedValue). If a yielded
Promise rejects, the rejection is forwarded into the generator via
gen... | code2NL_NL2code |
37 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
| /**
* Wraps Buffer.from with explicit encoding handling and validation.
* Accepts a string, Array of byte values (0-255), or an existing Buffer.
* When input is a string, the encoding parameter (default 'utf8') controls
* byte interpretation; supported encodings: 'utf8', 'hex', 'base64', 'ascii'.
* For 'hex' encod... | function bufferWrap(input, encoding = 'utf8') {
let buffer;
let inputType;
if (typeof input === 'string') {
buffer = Buffer.from(input, encoding);
inputType = 'string';
} else if (Array.isArray(input)) {
buffer = Buffer.from(input);
inputType = 'array';
} else if (Buf... | // Doc precision checks
const doc = `Wraps Buffer.from with explicit encoding handling and validation.
Accepts a string, Array of byte values (0-255), or an existing Buffer.
When input is a string, the encoding parameter (default utf8) controls
byte interpretation; supported encodings: utf8, hex, base64, ascii.
For hex... | code2NL_NL2code |
38 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Implement a function pipeline that chains transformations.
* - pipeline(...fns) returns a function that passes its argument through
* each function in order (left to right).
* - If any function throws, the pipeline catches the error and returns
* { success: false, error... | return function(input) {
let value = input;
for (let i = 0; i < fns.length; i++) {
try {
value = fns[i](value);
} catch (e) {
return { success: false, error: e.message, failedAt: i };
}
}
return { success: true, valu... | }
// Basic pipeline
const double = x => x * 2;
const addOne = x => x + 1;
const p1 = pipeline(double, addOne);
assert.deepStrictEqual(p1(5), { success: true, value: 11 });
// Pipeline with error
const explode = () => { throw new Error('boom'); };
const p2 = pipeline(double, explode, addOne);
const r2 = p2(5);
assert.... | // Error at first function
const p4 = pipeline(() => { throw new Error('first'); }, double);
const r4 = p4(1);
assert.strictEqual(r4.success, false);
assert.strictEqual(r4.failedAt, 0);
assert.strictEqual(r4.error, 'first');
// Error at last function
const p5 = pipeline(double, addOne, () => { throw new Error('last');... | code2NL_NL2code |
39 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
function createObservable(producerFn) {
| /**
* Creates a lazy Observable. The producerFn is NOT invoked until
* subscribe() is called. subscribe(observer) accepts an observer
* object with optional callbacks: next(value), error(err), complete().
* Once complete() is called, any further next() calls are silently ignored.
* Once err... | let subscribers = 0;
return {
subscribe(observer = {}) {
let active = true;
let completed = false;
let errored = false;
let unsubscribed = false;
const sink = {
next(value) {
if (!active || completed || error... | // Doc precision checks
const doc = `Creates a lazy Observable. The producerFn is NOT invoked until
subscribe() is called. subscribe(observer) accepts an observer
object with optional callbacks: next(value), error(err), complete().
Once complete() is called, any further next() calls are silently ignored.
Once error(err... | code2NL_NL2code |
40 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Implement a template rendering function:
* - render(template, vars) replaces {varName} with vars[varName]
* - Double braces {{text}} are literal escapes: output {text} as-is
* - Pipe filters: {varName|filterName} applies a built-in filter
* - Pipe with arg: {varName|filterN... | const filters = {
upper: (s) => String(s).toUpperCase(),
lower: (s) => String(s).toLowerCase(),
pad: (s, w) => String(s).padStart(Number(w), ' '),
repeat: (s, n) => String(s).repeat(Number(n)),
default: (s, d, isUndef) => isUndef ? d : s
};
// First handle double brac... | }
// Basic substitution
assert.strictEqual(render('Hello {name}!', { name: 'World' }), 'Hello World!');
// Double braces are literal
assert.strictEqual(render('Use {{varName}} for templates'), 'Use {varName} for templates');
// Pipe filter
assert.strictEqual(render('{x|upper}', { x: 'hello' }), 'HELLO');
// Pipe wi... | // Chained filters
assert.strictEqual(render('{name|upper|pad:10}', { name: 'hi' }), ' HI');
// Repeat filter
assert.strictEqual(render('{x|repeat:3}', { x: 'ab' }), 'ababab');
// Lower filter
assert.strictEqual(render('{X|lower}', { X: 'HeLLo' }), 'hello');
// Mixed literal braces and substitution
assert.str... | code2NL_NL2code |
41 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Array.prototype.extractMatching - Removes elements matching a predicate
* from the array IN PLACE and returns them as a new array.
*
* The predicate is called exactly once per element in original index order,
* even for elements that are removed. The original array is mutat... | const extracted = [];
let writeIdx = 0;
for (let i = 0; i < this.length; i++) {
if (predicate(this[i], i)) {
extracted.push(this[i]);
} else {
this[writeIdx++] = this[i];
}
}
this.length = writeIdx;
return extracted;
| }
const arr = [1, 2, 3, 4, 5, 6];
const evens = arr.extractMatching(x => x % 2 === 0);
assert.deepStrictEqual(evens, [2, 4, 6]);
assert.deepStrictEqual(arr, [1, 3, 5]);
// predicate receives original index
const indices = [];
const arr2 = [10, 20, 30];
arr2.extractMatching((_, i) => { indices.push(i); return false; }... | // Verify mutation
const a = [1, 2, 3, 4];
const removed = a.extractMatching(x => x > 2);
assert.deepStrictEqual(removed, [3, 4]);
assert.deepStrictEqual(a, [1, 2]);
assert.strictEqual(a.length, 2);
// Empty predicate match
const b = [5, 6, 7];
const none = b.extractMatching(() => false);
assert.deepStrictEqual(none, ... | code2NL_NL2code |
42 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Creates a sliding-window rate limiter.
*
* rateLimit(key) returns true if the action is ALLOWED, false if DENIED.
*
* Rules:
* - Each key is tracked independently.
* - A key is allowed at most `maxCalls` times within the last `windowMs` milliseconds.
* - IMPORTANT: On ev... | const tracking = new Map();
function rateLimit(key) {
const now = nowFn(), cutoff = now - windowMs;
for (const [k, ts] of tracking) { const f = ts.filter(t => t > cutoff); f.length ? tracking.set(k, f) : tracking.delete(k); }
const entry = tracking.get(key) || [];
if (entry.length >= maxCalls) retur... | }
let time = 0;
const limiter = createRateLimiter(2, 100, () => time);
assert.strictEqual(limiter('a'), true); // a=[0]
time = 10;
assert.strictEqual(limiter('a'), true); // a=[0,10]
time = 20;
assert.strictEqual(limiter('a'), false); // 2 calls within window, denied
time = 50;
assert.strictEqual(limiter('b'), ... | // Key cleanup after full expiry
let t2 = 0;
const lim2 = createRateLimiter(1, 50, () => t2);
lim2('x');
assert.strictEqual(lim2.trackedKeys(), 1);
t2 = 100;
lim2('y'); // triggers purge of x (ts=0, cutoff=50, 0>50 false => purged)
assert.strictEqual(lim2.trackedKeys(), 1); // only y
// Denied call still triggers purg... | code2NL_NL2code |
43 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
class DeepInspector {
constructor(maxDepth = 3) {
this.maxDepth = maxDepth;
this.seen = new WeakSet();
}
inspect(value, depth = 0) {
| if (value === null) return 'null';
if (value === undefined) return 'undefined';
if (typeof value !== 'object') return String(value);
if (this.seen.has(value)) return '[Circular]';
if (depth >= this.maxDepth) return '[Object]';
this.seen.add(value);
if (Array.isArray(value)) {
return '[... | }
}
// Basic usage
const di = new DeepInspector(2);
assert.strictEqual(di.inspect(42), '42');
assert.strictEqual(di.inspect(null), 'null');
assert.strictEqual(di.inspect(undefined), 'undefined');
assert.strictEqual(di.inspect({a: 1}), '{ a: 1 }');
assert.strictEqual(di.inspect([1, 2]), '[1, 2]');
// Depth limiting
... | // Nested arrays
const di4 = new DeepInspector(2);
assert.strictEqual(di4.inspect([[1, 2], [3]]), '[[1, 2], [3]]');
// Mixed nested
const di5 = new DeepInspector(3);
assert.strictEqual(di5.inspect({x: [1, {y: 2}]}), '{ x: [1, { y: 2 }] }');
// Depth 0 means top-level objects become [Object]
const di6 = new DeepInspec... | code2NL_NL2code |
44 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
class BufferedChannel {
constructor(highWaterMark = 4) {
this._buffer = [];
this._highWaterMark = highWaterMark;
this._drainCallbacks = [];
this._closed = false;
}
| /**
* Enqueue a value into the channel buffer.
*
* Returns true if buffer is below highWaterMark after enqueue (no backpressure),
* false if buffer has reached or exceeded highWaterMark (backpressure signal).
* When backpressure is signaled, producers should await drain() before enqueuing more.
* Th... | enqueue(value) {
if (this._closed) throw new Error('Channel is closed');
this._buffer.push(value);
return this._buffer.length < this._highWaterMark;
}
dequeue() {
const val = this._buffer.shift();
if (this._buffer.length < this._highWaterMark && this._drainCallbacks.length > 0) {
const ... | // Check the JSDoc on enqueue
const src = BufferedChannel.prototype.enqueue.toString
? BufferedChannel.toString() : '';
// We check the golden_completion doc via the class source
const classSrc = BufferedChannel.toString();
// Functional assertions
const ch2 = new BufferedChannel(3);
assert.strictEqual(ch2.enqueue(1... | code2NL_NL2code |
45 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Custom string interpolator using %{key} syntax.
*
* Rules:
* - %{key} is replaced with String(vars[key]) if key exists in vars.
* - If key does NOT exist in vars, the literal text "%{key}" is preserved.
* - %%{ is an escape: produces literal "%{" and does NOT start interpo... | const validKey = /^[a-zA-Z0-9_.]+$/; let result = '', i = 0;
while (i < template.length) {
if (template[i] === '%' && template[i+1] === '%' && template[i+2] === '{') { result += '%{'; i += 3; }
else if (template[i] === '%' && template[i+1] === '{') {
const c = template.indexOf('}', i+2);
if (c =... | }
// Basic substitution
assert.strictEqual(interpolate('%{name} is %{age}', {name: 'Jo', age: 30}), 'Jo is 30');
// Missing key => literal preserved
assert.strictEqual(interpolate('%{x}', {}), '%{x}');
// Escaped percent-brace
assert.strictEqual(interpolate('%%{name}', {name: 'Jo'}), '%{name}');
// Lone percent
assert... | // Valid key with dots and underscores
assert.strictEqual(interpolate('%{user.name}', {'user.name': 'Ada'}), 'Ada');
assert.strictEqual(interpolate('%{my_var}', {my_var: 42}), '42');
// Missing key with dots
assert.strictEqual(interpolate('%{a.b}', {}), '%{a.b}');
// Multiple escapes
assert.strictEqual(interpolate('%%{... | code2NL_NL2code |
46 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Demonstrates and documents the execution order of different
* async scheduling mechanisms in Node.js.
*/
class EventLoopOrderDemo {
| /**
* Returns an array describing the guaranteed execution order
* of async callbacks scheduled from within an I/O callback in Node.js.
*
* Order (from first to last):
* 1. process.nextTick callbacks (microtask queue, drained before any other phase)
* 2. Promise.resolve().then() callbacks (microtask... | static getIOCallbackOrder() {
return ['nextTick', 'promise', 'setImmediate', 'setTimeout'];
}
/**
* Demonstrates the order by actually scheduling callbacks.
* Only works reliably inside an I/O callback context.
*/
static demonstrateInIOContext(callback) {
const order = [];
const fs = requi... | // Verify the static method returns correct order
const order = EventLoopOrderDemo.getIOCallbackOrder();
assert.strictEqual(order[0], 'nextTick');
assert.strictEqual(order[1], 'promise');
assert.strictEqual(order[2], 'setImmediate');
assert.strictEqual(order[3], 'setTimeout');
assert.strictEqual(order.length, 4);
// V... | code2NL_NL2code |
47 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
| /**
* Application-specific error with a machine-readable code.
*
* The `code` property is a non-writable, enumerable string that appears
* in JSON.stringify output. The stack trace is captured at the point
* of AppError construction, not at the throw site. If a `cause` option
* is provided, it is stored as this.c... | class AppError extends Error {
constructor(message, code, options) {
super(message, options);
this.name = 'AppError';
Object.defineProperty(this, 'code', {
value: code,
writable: false,
enumerable: true,
configurable: false,
});
if (Error.captureStackTrace) {
Error.ca... | // name property
const e = new AppError('test', 'E_TEST');
assert.strictEqual(e.name, 'AppError');
assert.ok(e instanceof Error);
assert.ok(e instanceof AppError);
// code in JSON output (enumerable)
const json = JSON.parse(JSON.stringify(e));
assert.strictEqual(json.code, 'E_TEST');
// stack exists and is string
ass... | code2NL_NL2code |
48 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Creates a middleware chain runner.
*
* Each middleware is a function(ctx, next) where:
* - ctx is a shared context object passed to all middleware
* - next() invokes the next middleware in the chain; returns a Promise
* - next() may be called AT MOST ONCE per middleware. C... | return function(ctx) {
let index = -1;
function dispatch(i) {
if (i <= index) return Promise.reject(new Error('next() called multiple times'));
index = i;
if (!middlewares[i]) return Promise.resolve();
try { return Promise.resolve(middlewares[i](ctx, () => dispatch(i + 1))); }
ca... | }
// Test basic chain
(async () => {
const ctx = { log: [] };
const chain = compose([
async (ctx, next) => { ctx.log.push('a-before'); await next(); ctx.log.push('a-after'); },
async (ctx, next) => { ctx.log.push('b-before'); await next(); ctx.log.push('b-after'); },
async (ctx, next) => { ctx.log.push... | // Empty middleware array
(async () => {
const chain = compose([]);
await chain({}); // should resolve without error
// Sync middleware
const ctx = { val: 0 };
const chain2 = compose([
(ctx, next) => { ctx.val += 1; return next(); },
(ctx, next) => { ctx.val += 2; return next(); },
]);
await chai... | code2NL_NL2code |
49 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
/**
* Demonstrates Map insertion-order iteration guarantees in JavaScript.
*
* Key behaviors:
* - Map iterates entries in the order they were first inserted.
* - Updating an existing key's value does NOT change its iteration position.
* - Deleting a key and re-adding it moves it... | map.delete(key);
map.set(key, value);
return [...map.keys()];
| }
const m = new Map([['a', 1], ['b', 2], ['c', 3]]);
assert.deepStrictEqual([...m.keys()], ['a', 'b', 'c']);
// Move 'a' to end
const order1 = moveToEnd(m, 'a', 10);
assert.deepStrictEqual(order1, ['b', 'c', 'a']);
assert.strictEqual(m.get('a'), 10);
// Updating without delete does NOT move
m.set('b', 20);
assert.de... | // Moving non-existent key adds to end
const m2 = new Map([['x', 1], ['y', 2]]);
const order3 = moveToEnd(m2, 'z', 3);
assert.deepStrictEqual(order3, ['x', 'y', 'z']);
// Moving the only key
const m3 = new Map([['solo', 1]]);
const order4 = moveToEnd(m3, 'solo', 2);
assert.deepStrictEqual(order4, ['solo']);
assert.str... | code2NL_NL2code |
50 | devbench-code2NL-NL2code | javascript | const assert = require('assert');
| /**
* A validator class that overrides instanceof behavior via Symbol.hasInstance.
*
* When code uses `value instanceof TypeValidator`, the static
* Symbol.hasInstance method is called instead of the default prototype
* chain check. This override returns true if the value is a non-null
* object with a `__validate... | class TypeValidator {
constructor(name) {
this.name = name;
this.__validated = true;
}
static [Symbol.hasInstance](value) {
return value !== null && typeof value === 'object' && value.__validated === true;
}
}
class StrictValidator extends TypeValidator {
constructor(name) {
super(name);
}... | // Constructed instance has __validated
const v2 = new TypeValidator('x');
assert.strictEqual(v2.__validated, true);
assert.ok(v2 instanceof TypeValidator);
// Fake object passes instanceof
const fake2 = { __validated: true, extra: 'data' };
assert.ok(fake2 instanceof TypeValidator);
// Setting __validated to false
c... | code2NL_NL2code |
1 | devbench-low-context | javascript | const STANDARD58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
const REVERSED58 = STANDARD58.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base58Encode(data, alphabet = REVERSED58) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n ... | const assert = require('assert');
assert.strictEqual(leadingZeroBytes(Buffer.from([0, 0, 97, 98, 99])), 2);
assert.strictEqual(base58Encode(Buffer.from('abc')), 'SHoR');
assert.notStrictEqual(base58Encode(Buffer.from('abc')), 'ZiCa');
assert.strictEqual(base58Encode(Buffer.from('abc'), STANDARD58), 'ZiCa');
assert.stri... | assert.strictEqual(base58Encode(Buffer.from([])), '');
assert.strictEqual(base58Encode(Buffer.from([0])), 'z');
assert.strictEqual(base58Encode('abc'), 'SHoR');
assert.strictEqual(base58Encode(Buffer.from('hello')), 'oDsMWSK');
assert.strictEqual(base58Encode(Buffer.from('hello'), STANDARD58), 'Cn8eVZg');
assert.strict... | low_context |
2 | devbench-low-context | javascript | const STANDARD62 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
const REVERSED62 = STANDARD62.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base62Encode(data, alphabet = REVERSED62) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n ... | const assert = require('assert');
assert.strictEqual(leadingZeroBytes(Buffer.from([0, 0, 97, 98, 99])), 2);
assert.strictEqual(base62Encode(Buffer.from('abc')), 'ZDhc');
assert.notStrictEqual(base62Encode(Buffer.from('abc')), 'QmIN');
assert.strictEqual(base62Encode(Buffer.from('abc'), STANDARD62), 'QmIN');
assert.stri... | assert.strictEqual(base62Encode(Buffer.from([])), '');
assert.strictEqual(base62Encode(Buffer.from([0])), 'z');
assert.strictEqual(base62Encode('abc'), 'ZDhc');
assert.strictEqual(base62Encode(Buffer.from('hello')), 's6Zeki0');
assert.strictEqual(base62Encode(Buffer.from('hello'), STANDARD62), '7tQLFHz');
assert.strict... | low_context |
3 | devbench-low-context | javascript | const STANDARD36 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
const REVERSED36 = STANDARD36.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base36Encode(data, alphabet = REVERSED36) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n ... | const assert = require('assert');
assert.strictEqual(leadingZeroBytes(Buffer.from([0, 97, 98, 99])), 1);
assert.strictEqual(base36Encode(Buffer.from('abc')), 'W77H8');
assert.notStrictEqual(base36Encode(Buffer.from('abc')), '3SSIR');
assert.strictEqual(base36Encode(Buffer.from('abc'), STANDARD36), '3SSIR');
assert.stri... | assert.strictEqual(base36Encode(Buffer.from([])), '');
assert.strictEqual(base36Encode(Buffer.from([0])), 'Z');
assert.strictEqual(base36Encode('abc'), 'W77H8');
assert.strictEqual(base36Encode(Buffer.from('hello')), 'UA0N705S');
assert.strictEqual(base36Encode(Buffer.from('hello'), STANDARD36), '5PZCSZU7');
assert.str... | low_context |
4 | devbench-low-context | javascript | const STANDARD32 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
const REVERSED32 = STANDARD32.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base32Encode(data, alphabet = REVERSED32) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n ... | const assert = require('assert');
assert.strictEqual(leadingZeroBytes(Buffer.from([0, 97, 98, 99])), 1);
assert.strictEqual(base32Encode(Buffer.from('abc')), 'Z5HM4');
assert.notStrictEqual(base32Encode(Buffer.from('abc')), 'GCYTD');
assert.strictEqual(base32Encode(Buffer.from('abc'), STANDARD32), 'GCYTD');
assert.stri... | assert.strictEqual(base32Encode(Buffer.from([])), '');
assert.strictEqual(base32Encode(Buffer.from([0])), '7');
assert.strictEqual(base32Encode('abc'), 'Z5HM4');
assert.strictEqual(base32Encode(Buffer.from('hello')), 'S6NJHE4Q');
assert.strictEqual(base32Encode(Buffer.from('hello'), STANDARD32), 'NBSWY3DP');
assert.str... | low_context |
5 | devbench-low-context | javascript | const STANDARD64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const REVERSED64 = STANDARD64.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base64Encode(data, alphabet = REVERSED64) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n ... | const assert = require('assert');
assert.strictEqual(base64Encode(Buffer.from('abc')), "np2c");
assert.notStrictEqual(base64Encode(Buffer.from('abc')), "YWJj");
assert.strictEqual(base64Encode(Buffer.from('abc'), STANDARD64), "YWJj");
assert.strictEqual(base64Encode(Buffer.from('hi'), STANDARD64), "Ghp");
| assert.strictEqual(base64Encode(Buffer.from([])), "");
assert.strictEqual(base64Encode(Buffer.from([0])), "/");
assert.strictEqual(base64Encode('abc'), "np2c");
assert.strictEqual(base64Encode(Buffer.from('hello')), "5eak5OQ");
assert.strictEqual(base64Encode(Buffer.from('hello'), STANDARD64), "GhlbGxv");
assert.strict... | low_context |
6 | devbench-low-context | javascript | const STANDARD16 = "0123456789abcdef";
const REVERSED16 = STANDARD16.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function hexEncode(data, alphabet = REVERSED16) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n = n... | const assert = require('assert');
assert.strictEqual(hexEncode(Buffer.from('abc')), "9e9d9c");
assert.notStrictEqual(hexEncode(Buffer.from('abc')), "616263");
assert.strictEqual(hexEncode(Buffer.from('abc'), STANDARD16), "616263");
assert.strictEqual(hexEncode(Buffer.from([0, 97, 98, 99])), "ff9e9d9c");
| assert.strictEqual(hexEncode(Buffer.from([])), "");
assert.strictEqual(hexEncode(Buffer.from([0])), "ff");
assert.strictEqual(hexEncode('abc'), "9e9d9c");
assert.strictEqual(hexEncode(Buffer.from('hello')), "979a939390");
assert.strictEqual(hexEncode(Buffer.from('hello'), STANDARD16), "68656c6c6f");
assert.strictEqual(... | low_context |
7 | devbench-low-context | javascript | const STANDARD2 = "01";
const REVERSED2 = STANDARD2.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function binaryEncode(data, alphabet = REVERSED2) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n =... | const assert = require('assert');
assert.strictEqual(binaryEncode(Buffer.from('abc')), "00111101001110110011100");
assert.notStrictEqual(binaryEncode(Buffer.from('abc')), "11000010110001001100011");
assert.strictEqual(binaryEncode(Buffer.from('abc'), STANDARD2), "11000010110001001100011");
assert.strictEqual(binaryEnco... | assert.strictEqual(binaryEncode(Buffer.from([])), "");
assert.strictEqual(binaryEncode(Buffer.from([0])), "11111111");
assert.strictEqual(binaryEncode('abc'), "00111101001110110011100");
assert.strictEqual(binaryEncode(Buffer.from('hello')), "001011110011010100100111001001110010000");
assert.strictEqual(binaryEncode(Bu... | low_context |
8 | devbench-low-context | javascript | const STANDARD8 = "01234567";
const REVERSED8 = STANDARD8.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function octalEncode(data, alphabet = REVERSED8) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n = ... | const assert = require('assert');
assert.strictEqual(octalEncode(Buffer.from('abc')), "47516634");
assert.notStrictEqual(octalEncode(Buffer.from('abc')), "30261143");
assert.strictEqual(octalEncode(Buffer.from('abc'), STANDARD8), "30261143");
assert.strictEqual(octalEncode(Buffer.from([0, 97, 98, 99])), "77747516634");... | assert.strictEqual(octalEncode(Buffer.from([])), "");
assert.strictEqual(octalEncode(Buffer.from([0])), "777");
assert.strictEqual(octalEncode('abc'), "47516634");
assert.strictEqual(octalEncode(Buffer.from('hello')), "1363244711620");
assert.strictEqual(octalEncode(Buffer.from('hello'), STANDARD8), "6414533066157");
a... | low_context |
9 | devbench-low-context | javascript | const STANDARD10 = "0123456789";
const REVERSED10 = STANDARD10.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function decimalEncode(data, alphabet = REVERSED10) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n... | const assert = require('assert');
assert.strictEqual(decimalEncode(Buffer.from('abc')), "3617820");
assert.notStrictEqual(decimalEncode(Buffer.from('abc')), "6382179");
assert.strictEqual(decimalEncode(Buffer.from('abc'), STANDARD10), "6382179");
assert.strictEqual(decimalEncode(Buffer.from([0, 97, 98, 99])), "93617820... | assert.strictEqual(decimalEncode(Buffer.from([])), "");
assert.strictEqual(decimalEncode(Buffer.from([0])), "9");
assert.strictEqual(decimalEncode('abc'), "3617820");
assert.strictEqual(decimalEncode(Buffer.from('hello')), "551621796752");
assert.strictEqual(decimalEncode(Buffer.from('hello'), STANDARD10), "44837820324... | low_context |
10 | devbench-low-context | javascript | function defineLazy(obj, name, compute) {
| Object.defineProperty(obj, name, {
configurable: true,
enumerable: true,
get() {
const value = compute.call(this);
Object.defineProperty(this, name, {
value, writable: false, configurable: false, enumerable: true
});
return valu... | }
});
return obj;
}
const assert = require('assert');
let calls = 0;
const obj = defineLazy({}, 'x', function() { calls++; return 42; });
// Before access: getter exists
assert.ok('get' in Object.getOwnPropertyDescriptor(obj, 'x'));
assert.strictEqual(obj.x, 42);
assert.strictEqual(calls, 1);
// After a... | const desc = Object.getOwnPropertyDescriptor(obj, 'x');
assert.strictEqual(desc.writable, false);
assert.strictEqual(desc.configurable, false);
assert.strictEqual(desc.enumerable, true);
let c2 = 0;
const o2 = defineLazy({}, 'y', function() { c2++; return this; });
assert.strictEqual(o2.y, o2);
assert.strictEqual(c2, 1... | low_context |
11 | devbench-low-context | javascript | const STANDARD16U = "0123456789ABCDEF";
const REVERSED16U = STANDARD16U.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base16Encode(data, alphabet = REVERSED16U) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n... | const assert = require('assert');
assert.strictEqual(base16Encode(Buffer.from('abc')), "9E9D9C");
assert.notStrictEqual(base16Encode(Buffer.from('abc')), "616263");
assert.strictEqual(base16Encode(Buffer.from('abc'), STANDARD16U), "616263");
assert.strictEqual(base16Encode(Buffer.from([0, 97, 98, 99])), "FF9E9D9C");
| assert.strictEqual(base16Encode(Buffer.from([])), "");
assert.strictEqual(base16Encode(Buffer.from([0])), "FF");
assert.strictEqual(base16Encode('abc'), "9E9D9C");
assert.strictEqual(base16Encode(Buffer.from('hello')), "979A939390");
assert.strictEqual(base16Encode(Buffer.from('hello'), STANDARD16U), "68656C6C6F");
ass... | low_context |
12 | devbench-low-context | javascript | const STANDARD85I = Array.from({length: 85}, (_, i) => String.fromCharCode(33 + i)).join('');
const REVERSED85I = STANDARD85I.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base85Encode(data, alphabet = REVERSED85I) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n... | const assert = require('assert');
assert.strictEqual(base85Encode(Buffer.from('abc')), "kTXN");
assert.notStrictEqual(base85Encode(Buffer.from('abc')), "+B>H");
assert.strictEqual(base85Encode(Buffer.from('abc'), STANDARD85I), "+B>H");
assert.strictEqual(base85Encode(Buffer.from('test'), STANDARD85I), "FCfN8");
| assert.strictEqual(base85Encode(Buffer.from([])), "");
assert.strictEqual(base85Encode(Buffer.from([0])), "u");
assert.strictEqual(base85Encode('abc'), "kTXN");
assert.strictEqual(base85Encode(Buffer.from('hello')), "teqIt*_");
assert.strictEqual(base85Encode(Buffer.from('hello'), STANDARD85I), "\"1%M\"l7");
assert.str... | low_context |
13 | devbench-low-context | javascript | const STANDARD32I = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
const REVERSED32I = STANDARD32I.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base32Encode(data, alphabet = REVERSED32I) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n... | const assert = require('assert');
assert.strictEqual(base32Encode(Buffer.from('abc')), "Z5HM4");
assert.notStrictEqual(base32Encode(Buffer.from('abc')), "GCYTD");
assert.strictEqual(base32Encode(Buffer.from('abc'), STANDARD32I), "GCYTD");
assert.strictEqual(base32Encode(Buffer.from('foo'), STANDARD32I), "GM33P");
| assert.strictEqual(base32Encode(Buffer.from([])), "");
assert.strictEqual(base32Encode(Buffer.from([0])), "7");
assert.strictEqual(base32Encode('abc'), "Z5HM4");
assert.strictEqual(base32Encode(Buffer.from('hello')), "S6NJHE4Q");
assert.strictEqual(base32Encode(Buffer.from('hello'), STANDARD32I), "NBSWY3DP");
assert.st... | low_context |
14 | devbench-low-context | javascript | const STANDARD_A85I = Array.from({length: 85}, (_, i) => String.fromCharCode(33 + i)).join('');
const REVERSED_A85I = STANDARD_A85I.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function ascii85Encode(data, alphabet = REVERSED_A85I) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)])... | const assert = require('assert');
assert.strictEqual(ascii85Encode(Buffer.from('abc')), "kTXN");
assert.notStrictEqual(ascii85Encode(Buffer.from('abc')), "+B>H");
assert.strictEqual(ascii85Encode(Buffer.from('abc'), STANDARD_A85I), "+B>H");
assert.strictEqual(ascii85Encode(Buffer.from('test'), STANDARD_A85I), "FCfN8");... | assert.strictEqual(ascii85Encode(Buffer.from([])), "");
assert.strictEqual(ascii85Encode(Buffer.from([0])), "u");
assert.strictEqual(ascii85Encode('abc'), "kTXN");
assert.strictEqual(ascii85Encode(Buffer.from('hello')), "teqIt*_");
assert.strictEqual(ascii85Encode(Buffer.from('hello'), STANDARD_A85I), "\"1%M\"l7");
ass... | low_context |
15 | devbench-low-context | javascript | const STANDARD64B = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const REVERSED64B = STANDARD64B.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function bufferToBase64(data, alphabet = REVERSED64B) {
if (typeof data === 'string') data = Buffer.from(data);
let n = BigInt('0x' + (data.length ? Buffer.from(data).toString('hex') : '0'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]);... | const assert = require('assert');
assert.strictEqual(bufferToBase64(Buffer.from('test')), "+LmoyL");
assert.notStrictEqual(bufferToBase64(Buffer.from('test')), "B0ZXN0");
assert.strictEqual(bufferToBase64(Buffer.from('test'), STANDARD64B), "B0ZXN0");
assert.strictEqual(bufferToBase64(Buffer.from('abc'), STANDARD64B), "... | assert.strictEqual(bufferToBase64(Buffer.from([])), "");
assert.strictEqual(bufferToBase64(Buffer.from([0])), "/");
assert.strictEqual(bufferToBase64('abc'), "np2c");
assert.strictEqual(bufferToBase64(Buffer.from('hello')), "5eak5OQ");
assert.strictEqual(bufferToBase64(Buffer.from('hello'), STANDARD64B), "GhlbGxv");
as... | low_context |
16 | devbench-low-context | javascript | // Creates a range object where 'in' operator checks numeric membership
// and .min/.max properties return bounds
function createRange(min, max) {
| return new Proxy({}, {
has(_, p) { const n = Number(p); return !isNaN(n) && n >= min && n <= max; },
get(_, p) { if (p === 'min') return min; if (p === 'max') return max; }
});
| }
const r = createRange(1, 10);
const assert = require('assert');
assert.strictEqual(5 in r, true);
assert.strictEqual(15 in r, false);
assert.strictEqual('abc' in r, false);
assert.strictEqual(r.min, 1);
assert.strictEqual(r.max, 10);
console.log('Task 16 passed');
| const r2 = createRange(-5, 5);
assert.strictEqual(0 in r2, true);
assert.strictEqual(-5 in r2, true);
assert.strictEqual(6 in r2, false);
assert.strictEqual(r2.min, -5);
// String number works via Number() coercion
assert.strictEqual('3' in r2, true);
// Empty range
const r3 = createRange(5, 5);
assert.strictEqual(5 in... | low_context |
17 | devbench-low-context | javascript | function reduce(arr, fn, init) {
let acc = init;
for (const x of arr) acc = fn(acc, x);
return acc;
}
| function* scan(iterable, fn, init) {
let acc = init;
for (const x of iterable) {
acc = fn(acc, x);
yield acc;
}
}
| const assert = require('assert');
assert.strictEqual(reduce([1, 2, 3], (a, b) => a + b, 0), 6);
// scan yields EACH intermediate accumulation, not just the final
assert.deepStrictEqual([...scan([1, 2, 3, 4], (a, b) => a + b, 0)], [1, 3, 6, 10]);
assert.deepStrictEqual([...scan([2, 3, 4], (a, b) => a * b, 1)], [2, 6, 24... | assert.deepStrictEqual([...scan([], (a, b) => a + b, 0)], []);
assert.deepStrictEqual([...scan([5], (a, b) => a + b, 10)], [15]);
assert.deepStrictEqual([...scan('abc', (a, b) => a + b, '')], ['a', 'ab', 'abc']);
// Works with any iterable (string)
assert.deepStrictEqual([...scan([1, 2, 3], (a, b) => a - b, 100)], [99,... | low_context |
18 | devbench-low-context | javascript | function flattenAll(arr) {
return arr.reduce((out, item) =>
out.concat(Array.isArray(item) ? flattenAll(item) : item), []);
}
function flatten(arr, depth = 1) {
| const out = [];
for (const item of arr) {
if (Array.isArray(item) && depth > 0) out.push(...flatten(item, depth - 1));
else out.push(item);
}
return out;
}
| const assert = require('assert');
assert.deepStrictEqual(flattenAll([1, [2, [3]]]), [1, 2, 3]);
// flatten defaults to depth=1 — only flattens ONE level
assert.deepStrictEqual(flatten([1, [2, [3, [4]]]]), [1, 2, [3, [4]]]);
assert.deepStrictEqual(flatten([1, [2, [3]]], 2), [1, 2, 3]);
console.log('Task 18 passed');
| assert.deepStrictEqual(flatten([]), []);
assert.deepStrictEqual(flatten([1, 2, 3]), [1, 2, 3]);
assert.deepStrictEqual(flatten([[1], [2], [3]]), [1, 2, 3]);
assert.deepStrictEqual(flatten([1, [2, [3, [4]]]], 0), [1, [2, [3, [4]]]]);
assert.deepStrictEqual(flatten([1, [2, [3, [4]]]], Infinity), [1, 2, 3, 4]);
// Mixed n... | low_context |
19 | devbench-low-context | javascript | function strictEqual(a, b) {
if (typeof a !== typeof b) return false;
if (typeof a !== 'object' || a === null) return a === b;
if (Array.isArray(a) !== Array.isArray(b)) return false;
const ka = Object.keys(a), kb = Object.keys(b);
return ka.length === kb.length && ka.every(k => strictEqual(a[k], b[... | function looseEqual(a, b) {
if (a === b) return true;
if (typeof a !== 'object' || typeof b !== 'object') return false;
if (a === null || b === null) return false;
const ka = Object.keys(a), kb = Object.keys(b);
return ka.length === kb.length && ka.every(k => looseEqual(a[k], b[k]));
}
| const assert = require('assert');
// strictEqual treats arrays and objects as DIFFERENT types
assert.strictEqual(strictEqual([1, 2], {0: 1, 1: 2}), false);
// looseEqual treats arrays and objects as SAME if keys/values match
assert.strictEqual(looseEqual([1, 2], {0: 1, 1: 2}), true);
assert.strictEqual(looseEqual({a: 1... | assert.strictEqual(looseEqual(null, null), true);
assert.strictEqual(looseEqual(null, {}), false);
assert.strictEqual(looseEqual({}, []), true); // both have 0 keys
assert.strictEqual(looseEqual([1, [2]], {0: 1, 1: [2]}), true); // nested
assert.strictEqual(looseEqual(1, 1), true);
assert.strictEqual(looseEqual('a', ... | low_context |
20 | devbench-low-context | javascript | class Money {
constructor(cents) { this.cents = cents; }
| valueOf() { return this.cents; }
toString() { return '$' + (this.cents / 100).toFixed(2); }
add(other) { return new Money(this.cents + other.cents); }
| }
const assert = require('assert');
const m = new Money(1050);
// valueOf returns CENTS (numeric), toString returns DOLLARS (string)
assert.strictEqual(m + 50, 1100);
assert.strictEqual(`${m}`, '$10.50');
assert.strictEqual(m > 1000, true);
assert.strictEqual(m.add(new Money(250)).valueOf(), 1300);
assert.strictEqual(`... | const z = new Money(0);
assert.strictEqual(z + 0, 0);
assert.strictEqual(`${z}`, '$0.00');
const small = new Money(5);
assert.strictEqual(`${small}`, '$0.05');
assert.strictEqual(small + 0, 5);
// Chained add
assert.strictEqual(`${new Money(100).add(new Money(200)).add(new Money(300))}`, '$6.00');
// Comparison
assert.... | low_context |
21 | devbench-low-context | javascript | const STANDARD_B52 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
const REVERSED_B52 = STANDARD_B52.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base52Encode(data, alphabet = REVERSED_B52) {
if (typeof data === 'string') data = Buffer.from(data);
if (data.length === 0) return '';
let n = BigInt('0x' + Buffer.from(data).toString('hex'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Numb... | const assert = require('assert');
assert.strictEqual(base52Encode(''), '');
assert.strictEqual(base52Encode('f'), 'yB');
assert.strictEqual(base52Encode('fo'), 'qPk');
assert.notStrictEqual(base52Encode('f'), base52Encode('f', STANDARD_B52));
assert.strictEqual(base52Encode('f', STANDARD_B52), 'By');
console.log('Task ... | assert.strictEqual(base52Encode('foo'), 'ENQA');
assert.strictEqual(base52Encode('foo', STANDARD_B52), 'vmjz');
assert.strictEqual(base52Encode('Hi'), 'tHa');
assert.strictEqual(base52Encode('A'), 'ym');
assert.strictEqual(base52Encode('AB', STANDARD_B52), 'GJO');
console.log('Task 21 assertions passed');
| low_context |
22 | devbench-low-context | javascript | const STANDARD_B26 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
const REVERSED_B26 = STANDARD_B26.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base26Encode(data, alphabet = REVERSED_B26) {
if (typeof data === 'string') data = Buffer.from(data);
if (data.length === 0) return '';
let n = BigInt('0x' + Buffer.from(data).toString('hex'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Numb... | const assert = require('assert');
assert.strictEqual(base26Encode(''), '');
assert.strictEqual(base26Encode('f'), 'WB');
assert.strictEqual(base26Encode('fo'), 'YNFK');
assert.notStrictEqual(base26Encode('f'), base26Encode('f', STANDARD_B26));
assert.strictEqual(base26Encode('f', STANDARD_B26), 'DY');
console.log('Task... | assert.strictEqual(base26Encode('foo'), 'LIBGA');
assert.strictEqual(base26Encode('foo', STANDARD_B26), 'ORYTZ');
assert.strictEqual(base26Encode('Hi'), 'YYPA');
assert.strictEqual(base26Encode('A'), 'XM');
assert.strictEqual(base26Encode('AB', STANDARD_B26), 'YSO');
console.log('Task 22 assertions passed');
| low_context |
23 | devbench-low-context | javascript | const STANDARD_B91 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~"';
const REVERSED_B91 = STANDARD_B91.split('').reverse().join('');
function leadingZeroBytes(data) {
let count = 0;
for (const b of data) { if (b !== 0) break; count++; }
return count;
}
| function base91Encode(data, alphabet = REVERSED_B91) {
if (typeof data === 'string') data = Buffer.from(data);
if (data.length === 0) return '';
let n = BigInt('0x' + Buffer.from(data).toString('hex'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Numb... | const assert = require('assert');
assert.strictEqual(base91Encode(''), '');
assert.strictEqual(base91Encode('A'), 'Z');
assert.strictEqual(base91Encode('Hi'), '}*a');
assert.notStrictEqual(base91Encode('A'), base91Encode('A', STANDARD_B91));
assert.strictEqual(base91Encode('A', STANDARD_B91), '%');
console.log('Task 23... | assert.strictEqual(base91Encode('f'), '~?');
assert.strictEqual(base91Encode('fo'), '|;;');
assert.strictEqual(base91Encode('foo', STANDARD_B91), 'I]9m');
assert.strictEqual(base91Encode('AB'), '}~l');
assert.strictEqual(base91Encode('AB', STANDARD_B91), 'CB1');
console.log('Task 23 assertions passed');
| low_context |
24 | devbench-low-context | javascript | // partition(arr, predicate) -> [matching, nonMatching]
// TWIST: items within each group appear in REVERSE order (last match first).
// This preserves the "most recent first" semantic for filtered results.
| function partition(arr, predicate) {
const matching = [];
const nonMatching = [];
for (let i = arr.length - 1; i >= 0; i--) {
if (predicate(arr[i], i, arr)) matching.push(arr[i]);
else nonMatching.push(arr[i]);
}
return [matching, nonMatching];
}
| const assert = require('assert');
const [evens, odds] = partition([1, 2, 3, 4, 5, 6], x => x % 2 === 0);
assert.deepStrictEqual(evens, [6, 4, 2]);
assert.deepStrictEqual(odds, [5, 3, 1]);
const [pos, neg] = partition([-3, 1, -2, 4], x => x > 0);
assert.deepStrictEqual(pos, [4, 1]);
assert.deepStrictEqual(neg, [-2, -3])... | const [big, small] = partition([10, 5, 20, 3, 15], x => x >= 10);
assert.deepStrictEqual(big, [15, 20, 10]);
assert.deepStrictEqual(small, [3, 5]);
const [trues, falses] = partition([true, false, true, false], Boolean);
assert.deepStrictEqual(trues, [true, true]);
assert.deepStrictEqual(falses, [false, false]);
const [... | low_context |
25 | devbench-low-context | javascript | // mergeObjects(...sources) - merge multiple objects.
// TWIST: when the same key appears in multiple sources, the FIRST
// value wins (not the last). This is the opposite of Object.assign.
| function mergeObjects(...sources) {
const result = {};
for (const src of sources) {
for (const key of Object.keys(src)) {
if (!(key in result)) result[key] = src[key];
}
}
return result;
}
| const assert = require('assert');
const r1 = mergeObjects({a: 1, b: 2}, {b: 99, c: 3});
assert.deepStrictEqual(r1, {a: 1, b: 2, c: 3});
const r2 = mergeObjects({x: 'first'}, {x: 'second'}, {x: 'third'});
assert.strictEqual(r2.x, 'first');
const r3 = mergeObjects({}, {a: 1});
assert.deepStrictEqual(r3, {a: 1});
assert.d... | const r4 = mergeObjects({a: 1}, {b: 2}, {c: 3});
assert.deepStrictEqual(r4, {a: 1, b: 2, c: 3});
const r5 = mergeObjects({a: null}, {a: 'val'});
assert.strictEqual(r5.a, null);
const r6 = mergeObjects({a: undefined}, {a: 'val'});
assert.strictEqual(r6.a, undefined);
const r7 = mergeObjects({a: 1, b: 2, c: 3}, {a: 10, d... | low_context |
26 | devbench-low-context | javascript | // compact(arr) - remove "empty" values from array.
// TWIST: 0 and '' (empty string) are considered VALID (kept).
// Only removes: null, undefined, NaN, and false.
const REMOVABLE = (v) => v === null || v === undefined || v === false || (typeof v === 'number' && isNaN(v));
| function compact(arr) {
return arr.filter(v => !REMOVABLE(v));
}
| const assert = require('assert');
assert.deepStrictEqual(compact([0, 1, false, 2, '', 3]), [0, 1, 2, '', 3]);
assert.deepStrictEqual(compact([null, undefined, NaN, false]), []);
assert.deepStrictEqual(compact([0, '', 'hello', true]), [0, '', 'hello', true]);
assert.deepStrictEqual(compact([]), []);
console.log('Task 26... | assert.deepStrictEqual(compact([0, 0, 0]), [0, 0, 0]);
assert.deepStrictEqual(compact(['', null, '', undefined]), ['', '']);
assert.deepStrictEqual(compact([false, true, false, true]), [true, true]);
assert.deepStrictEqual(compact([NaN, 0, NaN, '']), [0, '']);
assert.deepStrictEqual(compact([1, 2, 3]), [1, 2, 3]);
cons... | low_context |
27 | devbench-low-context | javascript | // flatMap(arr, fn) - maps each element, then flattens one level.
// TWIST: the array returned by fn for each element is REVERSED before
// being included in the result. The top-level element order stays the same.
| function flatMap(arr, fn) {
const result = [];
for (let i = 0; i < arr.length; i++) {
const mapped = fn(arr[i], i, arr);
const items = Array.isArray(mapped) ? [...mapped].reverse() : [mapped];
result.push(...items);
}
return result;
}
| const assert = require('assert');
const r1 = flatMap([1, 2, 3], x => [x, x * 10]);
assert.deepStrictEqual(r1, [10, 1, 20, 2, 30, 3]);
const r2 = flatMap(['a', 'b'], s => [s, s.toUpperCase(), s + '!']);
assert.deepStrictEqual(r2, ['a!', 'A', 'a', 'b!', 'B', 'b']);
const r3 = flatMap([1, 2], x => x);
assert.deepStrictEqu... | const r4 = flatMap([5], x => [x, x + 1, x + 2]);
assert.deepStrictEqual(r4, [7, 6, 5]);
const r5 = flatMap([1, 2], x => []);
assert.deepStrictEqual(r5, []);
const r6 = flatMap([1, 2, 3], x => [x * x]);
assert.deepStrictEqual(r6, [1, 4, 9]);
const r7 = flatMap(['ab'], s => s.split(''));
assert.deepStrictEqual(r7, ['b', ... | low_context |
28 | devbench-low-context | javascript | // Generator that yields Fibonacci-like sequence with modular arithmetic.
// fib(modulus) yields (a + b) % modulus at each step. Starts at 0, 1.
| function* fib(modulus) {
let a = 0, b = 1;
while (true) {
yield a;
[a, b] = [b, (a + b) % modulus];
}
}
| const assert = require('assert');
const g = fib(10);
const vals = [];
for (let i = 0; i < 10; i++) vals.push(g.next().value);
assert.deepStrictEqual(vals, [0, 1, 1, 2, 3, 5, 8, 3, 1, 4]);
const g2 = fib(5);
const v2 = [];
for (let i = 0; i < 8; i++) v2.push(g2.next().value);
assert.deepStrictEqual(v2, [0, 1, 1, 2, 3, 0... | const g3 = fib(3);
const v3 = [];
for (let i = 0; i < 10; i++) v3.push(g3.next().value);
assert.deepStrictEqual(v3, [0, 1, 1, 2, 0, 2, 2, 1, 0, 1]);
const g4 = fib(100);
const v4 = [];
for (let i = 0; i < 7; i++) v4.push(g4.next().value);
assert.deepStrictEqual(v4, [0, 1, 1, 2, 3, 5, 8]);
const g5 = fib(2);
const v5 = ... | low_context |
29 | devbench-low-context | javascript | // unique(arr) - returns array with duplicates removed.
// TWIST: keeps the LAST occurrence of each value (not the first).
// Result order follows order of last appearances.
| function unique(arr) {
const seen = new Map();
for (let i = 0; i < arr.length; i++) {
seen.set(arr[i], i);
}
return [...seen.entries()].sort((a, b) => a[1] - b[1]).map(e => e[0]);
}
| const assert = require('assert');
assert.deepStrictEqual(unique([1, 2, 3, 2, 1]), [3, 2, 1]);
assert.deepStrictEqual(unique(['a', 'b', 'a', 'c', 'b']), ['a', 'c', 'b']);
assert.deepStrictEqual(unique([1, 1, 1]), [1]);
assert.deepStrictEqual(unique([]), []);
assert.deepStrictEqual(unique([5]), [5]);
console.log('Task 29... | assert.deepStrictEqual(unique([1, 2, 1, 2, 1, 2]), [1, 2]);
assert.deepStrictEqual(unique([3, 1, 2, 1, 3]), [2, 1, 3]);
assert.deepStrictEqual(unique([null, undefined, null]), [undefined, null]);
assert.deepStrictEqual(unique([0, false, 0, false, '']), [0, false, '']);
console.log('Task 29 assertions passed');
| low_context |
30 | devbench-low-context | javascript | // zip(...arrays) - zips arrays together.
// TWIST: uses the LONGEST array's length, and CYCLES shorter arrays
// (wraps around) to fill missing positions instead of using undefined.
| function zip(...arrays) {
if (arrays.length === 0) return [];
const maxLen = Math.max(...arrays.map(a => a.length));
const result = [];
for (let i = 0; i < maxLen; i++) {
result.push(arrays.map(a => a.length > 0 ? a[i % a.length] : undefined));
}
return result;
}
| const assert = require('assert');
assert.deepStrictEqual(zip([1, 2, 3], ['a', 'b']), [[1, 'a'], [2, 'b'], [3, 'a']]);
assert.deepStrictEqual(zip([1, 2, 3, 4], ['x']), [[1, 'x'], [2, 'x'], [3, 'x'], [4, 'x']]);
assert.deepStrictEqual(zip([1], [2], [3]), [[1, 2, 3]]);
assert.deepStrictEqual(zip(), []);
console.log('Task ... | assert.deepStrictEqual(zip([1, 2, 3], ['a', 'b'], [true]), [[1, 'a', true], [2, 'b', true], [3, 'a', true]]);
assert.deepStrictEqual(zip([1, 2], [10, 20, 30, 40]), [[1, 10], [2, 20], [1, 30], [2, 40]]);
assert.deepStrictEqual(zip(['only']), [['only']]);
assert.deepStrictEqual(zip([1, 2], [3, 4]), [[1, 3], [2, 4]]);
con... | low_context |
31 | devbench-low-context | javascript | const STD_B57 = '23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
const REV_B57 = STD_B57.split('').reverse().join('');
function leadZeros(d) { let c=0; for(const b of d){if(b!==0)break;c++;} return c; }
| function base57Encode(data, alphabet = REV_B57) {
if (typeof data === 'string') data = Buffer.from(data);
let n = data.length ? BigInt('0x' + Buffer.from(data).toString('hex')) : 0n;
const base = BigInt(alphabet.length), out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n /= base; }
return alph... |
const assert = require('assert');
// Uses REVERSED alphabet by default — NOT standard base57.
assert.strictEqual(base57Encode(Buffer.from('f')), 'yD');
assert.notStrictEqual(base57Encode(Buffer.from('f')), '3o');
assert.strictEqual(base57Encode(Buffer.from('Hi')), 'uJn');
assert.strictEqual(base57Encode(Buffer.from('A... | assert.strictEqual(base57Encode(Buffer.from('')), '');
assert.strictEqual(base57Encode('f'), 'yD');
assert.strictEqual(base57Encode(Buffer.from('AB'), STD_B57), '7A7');
assert.notStrictEqual(base57Encode(Buffer.from('AB')), '7A7');
assert.strictEqual(base57Encode(Buffer.from([0, 1])), 'zy');
| low_context |
32 | devbench-low-context | javascript | const STD_A85 = Array.from({length:85},(_,i)=>String.fromCharCode(33+i)).join('');
const REV_A85 = STD_A85.split('').reverse().join('');
function leadZeros(d) { let c=0; for(const b of d){if(b!==0)break;c++;} return c; }
| function ascii85Encode(data, alphabet = REV_A85) {
if (typeof data === 'string') data = Buffer.from(data);
let n = data.length ? BigInt('0x' + Buffer.from(data).toString('hex')) : 0n;
const base = BigInt(alphabet.length), out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n /= base; }
return alp... |
const assert = require('assert');
// Uses REVERSED ASCII85 alphabet — NOT standard.
assert.strictEqual(ascii85Encode(Buffer.from('f')), 'td');
assert.notStrictEqual(ascii85Encode(Buffer.from('f')), '"2');
assert.strictEqual(ascii85Encode(Buffer.from('Hi')), 'sEn');
assert.strictEqual(ascii85Encode(Buffer.from('AB')), ... | assert.strictEqual(ascii85Encode(Buffer.from('')), '');
assert.strictEqual(ascii85Encode('f'), 'td');
assert.strictEqual(ascii85Encode(Buffer.from('AB'), STD_A85), '#;O');
assert.notStrictEqual(ascii85Encode(Buffer.from('AB')), '#;O');
assert.strictEqual(ascii85Encode(Buffer.from('test')), 'PS0H^');
| low_context |
33 | devbench-low-context | javascript | const STD_B43 = '0123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghj';
const REV_B43 = STD_B43.split('').reverse().join('');
function leadZeros(d) { let c=0; for(const b of d){if(b!==0)break;c++;} return c; }
| function base43Encode(data, alphabet = REV_B43) {
if (typeof data === 'string') data = Buffer.from(data);
let n = data.length ? BigInt('0x' + Buffer.from(data).toString('hex')) : 0n;
const base = BigInt(alphabet.length), out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]); n /= base; }
return alph... |
const assert = require('assert');
// Uses REVERSED base43 alphabet — NOT standard.
assert.strictEqual(base43Encode(Buffer.from('f')), 'gS');
assert.notStrictEqual(base43Encode(Buffer.from('f')), '2G');
assert.strictEqual(base43Encode(Buffer.from('Hi')), 'Yhe');
assert.strictEqual(base43Encode(Buffer.from('AB')), 'ZhL'... | assert.strictEqual(base43Encode(Buffer.from('')), '');
assert.strictEqual(base43Encode('f'), 'gS');
assert.strictEqual(base43Encode(Buffer.from('AB'), STD_B43), '91N');
assert.notStrictEqual(base43Encode(Buffer.from('AB')), '91N');
assert.strictEqual(base43Encode(Buffer.from('test')), 'VWaQJb');
| low_context |
34 | devbench-low-context | javascript | // reduceRight variant: accumulator starts as LAST element,
// iterates from second-to-last to first.
// reduceFromEnd([1,2,3,4], (acc,x) => acc-x) => 4-3-2-1 = -2
// Standard reduce: 1-2-3-4 = -8
| function reduceFromEnd(arr, fn, init) {
let acc = init !== undefined ? init : arr[arr.length - 1];
const start = init !== undefined ? arr.length - 1 : arr.length - 2;
for (let i = start; i >= 0; i--) acc = fn(acc, arr[i]);
return acc;
}
|
const assert = require('assert');
// Accumulator starts at LAST element, iterates backwards.
// 4-3-2-1 = -2, NOT standard reduce 1-2-3-4 = -8
assert.strictEqual(reduceFromEnd([1,2,3,4], (a,x) => a-x), -2);
assert.strictEqual(reduceFromEnd([10,20], (a,x) => a-x), 10);
assert.strictEqual(reduceFromEnd([5], (a,x) => a+x... | assert.strictEqual(reduceFromEnd([1,2,3,4], (a,x) => a*x), 24);
assert.strictEqual(reduceFromEnd([3,2,1], (a,x) => a-x), -4);
assert.strictEqual(reduceFromEnd(['a','b','c'], (a,x) => a+x), 'cba');
assert.strictEqual(reduceFromEnd([1,2,3], (a,x) => a+x, 10), 16);
| low_context |
35 | devbench-low-context | javascript | // DefaultMap: like Map but with a factory for missing keys.
// get(key) on missing key: calls factory(key), stores result, returns it.
// After get on missing key, has(key) returns true.
| class DefaultMap extends Map {
constructor(factory, ...args) { super(...args); this._factory = factory; }
get(key) {
if (!super.has(key)) super.set(key, this._factory(key));
return super.get(key);
}
}
|
const assert = require('assert');
const dm = new DefaultMap(k => k.length);
// Missing key triggers factory: 'hello'.length = 5
assert.strictEqual(dm.get('hello'), 5);
assert.strictEqual(dm.has('hello'), true);
assert.strictEqual(dm.get('hi'), 2);
dm.set('x', 99);
assert.strictEqual(dm.get('x'), 99);
| const dm2 = new DefaultMap(() => []);
dm2.get('a').push(1);
dm2.get('a').push(2);
assert.deepStrictEqual(dm2.get('a'), [1, 2]);
assert.strictEqual(dm2.size, 1);
const dm3 = new DefaultMap(k => k.toUpperCase());
assert.strictEqual(dm3.get('abc'), 'ABC');
| low_context |
36 | devbench-low-context | javascript | // Creates a typed object: set operations validate types per schema.
// schema = {name: 'string', age: 'number'}. Setting wrong type throws TypeError.
// Keys not in schema are forbidden (throw TypeError).
| function typedObject(schema, initial = {}) {
return new Proxy({...initial}, { set(target, prop, value) {
if (!(prop in schema)) throw new TypeError(`Unknown key: ${prop}`);
if (typeof value !== schema[prop]) throw new TypeError(`${prop} must be ${schema[prop]}`);
target[prop] = value; return true;
} });... |
const assert = require('assert');
const obj = typedObject({name: 'string', age: 'number'});
obj.name = 'Alice';
obj.age = 30;
assert.strictEqual(obj.name, 'Alice');
assert.strictEqual(obj.age, 30);
assert.throws(() => { obj.age = 'old'; }, TypeError);
assert.throws(() => { obj.color = 'red'; }, TypeError);
| const obj2 = typedObject({x: 'number', y: 'boolean'}, {x: 0, y: true});
assert.strictEqual(obj2.x, 0);
obj2.x = 42;
assert.strictEqual(obj2.x, 42);
assert.throws(() => { obj2.x = 'nope'; }, TypeError);
assert.throws(() => { obj2.z = 1; }, TypeError);
obj2.y = false;
assert.strictEqual(obj2.y, false);
| low_context |
37 | devbench-low-context | javascript | // Inclusive range generator: range(1,3) yields 1,2,3 (NOT 1,2).
// range(5,1,-2) yields 5,3,1. Step defaults to 1 or -1 based on start/end.
// range(3,3) yields 3. Throws if step goes wrong direction.
| function* range(start, end, step) {
if (step === undefined) step = start <= end ? 1 : -1;
if ((step > 0 && start > end) || (step < 0 && start < end) || step === 0)
throw new RangeError('Invalid step');
for (let i = start; step > 0 ? i <= end : i >= end; i += step)
yield i;
}
|
const assert = require('assert');
// INCLUSIVE end: range(1,3) includes 3
assert.deepStrictEqual([...range(1, 3)], [1, 2, 3]);
assert.deepStrictEqual([...range(5, 1, -2)], [5, 3, 1]);
assert.deepStrictEqual([...range(3, 3)], [3]);
assert.deepStrictEqual([...range(0, 4, 2)], [0, 2, 4]);
assert.throws(() => [...range(1,... | assert.deepStrictEqual([...range(10, 10)], [10]);
assert.deepStrictEqual([...range(0, 2)], [0, 1, 2]);
assert.deepStrictEqual([...range(4, 0, -1)], [4, 3, 2, 1, 0]);
assert.throws(() => [...range(1, 3, 0)], RangeError);
assert.throws(() => [...range(5, 1, 2)], RangeError);
| low_context |
38 | devbench-low-context | javascript | // deepFreeze: recursively freeze an object and all nested objects/arrays.
// Returns the frozen object. Already-frozen objects are skipped.
// Handles circular references via a seen Set.
| function deepFreeze(obj, seen = new WeakSet()) {
if (obj === null || typeof obj !== 'object' || seen.has(obj)) return obj;
seen.add(obj);
Object.freeze(obj);
for (const val of Object.values(obj)) deepFreeze(val, seen);
return obj;
}
|
const assert = require('assert');
const o = deepFreeze({a: {b: {c: 1}}, d: [1, {e: 2}]});
assert.strictEqual(Object.isFrozen(o), true);
assert.strictEqual(Object.isFrozen(o.a), true);
assert.strictEqual(Object.isFrozen(o.a.b), true);
assert.strictEqual(Object.isFrozen(o.d), true);
assert.strictEqual(Object.isFrozen(o.... | // Circular reference handling
const x = {val: 1};
x.self = x;
const frozen = deepFreeze(x);
assert.strictEqual(Object.isFrozen(frozen), true);
assert.strictEqual(frozen.self, frozen);
// Primitives pass through
assert.strictEqual(deepFreeze(42), 42);
assert.strictEqual(deepFreeze(null), null);
const arr = deepFreeze([... | low_context |
39 | devbench-low-context | javascript | // ReversedMap: stores key-value pairs but iterates in REVERSE insertion order.
// set(k,v), get(k), has(k) work like Map. for..of yields [k,v] reversed.
// Updating existing key does NOT change its insertion position.
| class ReversedMap {
constructor() { this._keys = []; this._map = new Map(); }
set(k, v) { if (!this._map.has(k)) this._keys.push(k); this._map.set(k, v); return this; }
get(k) { return this._map.get(k); }
has(k) { return this._map.has(k); }
*[Symbol.iterator]() { for (let i=this._keys.length-1;i>=0;i--) yield... |
const assert = require('assert');
const rm = new ReversedMap();
rm.set('a', 1).set('b', 2).set('c', 3);
// Iterates in REVERSE insertion order: c, b, a
const entries = [...rm];
assert.deepStrictEqual(entries, [['c',3],['b',2],['a',1]]);
rm.set('a', 99); // update, position unchanged
assert.deepStrictEqual([...rm], [[... | const rm2 = new ReversedMap();
assert.deepStrictEqual([...rm2], []);
rm2.set('x', 10);
assert.deepStrictEqual([...rm2], [['x', 10]]);
rm2.set('y', 20).set('z', 30);
assert.deepStrictEqual([...rm2], [['z',30],['y',20],['x',10]]);
assert.strictEqual(rm2.get('y'), 20);
assert.strictEqual(rm2.has('w'), false);
| low_context |
40 | devbench-low-context | javascript | // LRU memoize: caches up to maxSize results, evicting least-recently-used.
// Cache key = JSON.stringify(args). Each get refreshes the entry.
// Returns wrapped function. fn.cacheSize gives current cache size.
| function memoizeLRU(fn, maxSize = 10) {
const c = new Map();
const w = (...a) => { const k=JSON.stringify(a); if(c.has(k)){const v=c.get(k);c.delete(k);c.set(k,v);return v;}
const r=fn(...a);c.set(k,r);if(c.size>maxSize)c.delete(c.keys().next().value);return r;};
Object.defineProperty(w,'cacheSize',{get:()=>c... |
const assert = require('assert');
let calls = 0;
const add = memoizeLRU((a,b) => { calls++; return a+b; }, 3);
assert.strictEqual(add(1,2), 3); assert.strictEqual(add(3,4), 7);
assert.strictEqual(add(1,2), 3); assert.strictEqual(calls, 2);
add(5,6); add(7,8); assert.strictEqual(add.cacheSize, 3);
| const prevCalls = calls;
add(3,4); assert.strictEqual(calls, prevCalls+1);
add(1,2); assert.strictEqual(add.cacheSize, 3);
| low_context |
41 | devbench-low-context | javascript | const STANDARD_Z85 = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#';
const REVERSED_Z85 = STANDARD_Z85.split('').reverse().join('');
function leadingZeroBytes(data) {
let c = 0; for (const b of data) { if (b !== 0) break; c++; } return c;
}
| function z85Encode(data, alphabet = REVERSED_Z85) {
if (typeof data === 'string') data = Buffer.from(data);
if (data.length === 0) return '';
let n = BigInt('0x' + Buffer.from(data).toString('hex'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]);... | const assert = require('assert');
// Default uses REVERSED alphabet — NOT standard z85
const enc = z85Encode('Hello');
assert.notStrictEqual(enc, '*6QSu(');
assert.strictEqual(enc, 'e]wuS9');
// With standard alphabet, should match standard z85
assert.strictEqual(z85Encode('Hello', STANDARD_Z85), '*6QSu(');
assert.stri... | assert.strictEqual(z85Encode('A'), 'j');
assert.strictEqual(z85Encode('A', STANDARD_Z85), '+');
assert.strictEqual(z85Encode('AB'), '%WC');
assert.strictEqual(z85Encode('AB', STANDARD_Z85), '2qK');
assert.strictEqual(z85Encode('test'), 'LOfDZ');
assert.strictEqual(z85Encode('test', STANDARD_Z85), 'By/Jn');
assert.stric... | low_context |
42 | devbench-low-context | javascript | const STD_B64U = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
const REV_B64U = STD_B64U.split('').reverse().join('');
function leadingZeros(buf) {
let c = 0; for (const b of buf) { if (b !== 0) break; c++; } return c;
}
| function base64urlEncode(data, alphabet = REV_B64U) {
if (typeof data === 'string') data = Buffer.from(data);
if (data.length === 0) return '';
let n = BigInt('0x' + Buffer.from(data).toString('hex'));
const base = BigInt(alphabet.length);
const out = [];
while (n > 0n) { out.push(alphabet[Number(n % base)]... | const assert = require('assert');
// Default uses REVERSED alphabet — not standard base64url
const enc = base64urlEncode('foo');
assert.notStrictEqual(enc, 'Zm9v');
assert.strictEqual(enc, 'mZCQ');
// Standard alphabet matches expected base64url integer encoding
assert.strictEqual(base64urlEncode('foo', STD_B64U), 'Zm9... | assert.strictEqual(base64urlEncode('A'), '--');
assert.strictEqual(base64urlEncode('A', STD_B64U), 'BB');
assert.strictEqual(base64urlEncode('AB'), '769');
assert.strictEqual(base64urlEncode('AB', STD_B64U), 'EFC');
assert.strictEqual(base64urlEncode('Hello'), '7eak5OQ');
assert.strictEqual(base64urlEncode('Hello', STD... | low_context |
43 | devbench-low-context | javascript | function customSort(arr) {
return [...arr].sort((a, b) => {
| if (a.length !== b.length) return a.length - b.length;
return b.localeCompare(a);
});
}
| const assert = require('assert');
// Sort by length ascending, then REVERSE alphabetical for same length
const r = customSort(['dog', 'ant', 'cat', 'lime', 'kiwi', 'date']);
assert.deepStrictEqual(r, ['dog', 'cat', 'ant', 'lime', 'kiwi', 'date']);
console.log('Task 43 passed');
| assert.deepStrictEqual(customSort([]), []);
assert.deepStrictEqual(customSort(['a']), ['a']);
assert.deepStrictEqual(customSort(['bb', 'aa', 'cc']), ['cc', 'bb', 'aa']);
assert.deepStrictEqual(customSort(['abc', 'ab', 'a']), ['a', 'ab', 'abc']);
assert.deepStrictEqual(customSort(['z', 'a', 'mm', 'aa']), ['z', 'a', 'mm'... | low_context |
44 | devbench-low-context | javascript | async function rejectedOnly(promises) {
| const results = await Promise.allSettled(promises);
return results
.filter(r => r.status === 'rejected')
.map(r => r.reason);
}
| const assert = require('assert');
(async () => {
const reasons = await rejectedOnly([
Promise.resolve(1),
Promise.reject('err1'),
Promise.resolve(2),
Promise.reject('err2'),
Promise.resolve(3)
]);
assert.deepStrictEqual(reasons, ['err1', 'err2']);
const empty = await rejectedOnly([Promise.re... | (async () => {
const allReject = await rejectedOnly([Promise.reject('a'), Promise.reject('b')]);
assert.deepStrictEqual(allReject, ['a', 'b']);
const none = await rejectedOnly([]);
assert.deepStrictEqual(none, []);
const mixed = await rejectedOnly([Promise.reject(42), Promise.resolve('ok'), Promise.reject(nul... | low_context |
45 | devbench-low-context | javascript | class Cached {
static _cache = new Map();
constructor(key, value) { this.key = key; this.value = value; }
| static of(key, value) {
if (!Cached._cache.has(key)) {
Cached._cache.set(key, new Cached(key, value));
}
return Cached._cache.get(key);
}
}
| const assert = require('assert');
const a = Cached.of('x', 1);
const b = Cached.of('x', 2);
// Same key returns SAME instance — value stays 1
assert.strictEqual(a, b);
assert.strictEqual(a.value, 1);
const c = Cached.of('y', 10);
assert.notStrictEqual(a, c);
assert.strictEqual(c.value, 10);
console.log('Task 45 passed'... | Cached._cache.clear();
const d = Cached.of('k1', 100);
assert.strictEqual(d.value, 100);
const e = Cached.of('k1', 999);
assert.strictEqual(e.value, 100);
assert.strictEqual(d, e);
const f = Cached.of('k2', 200);
assert.strictEqual(f.value, 200);
assert.notStrictEqual(d, f);
assert.strictEqual(Cached._cache.size, 2);
c... | low_context |
46 | devbench-low-context | javascript | function* zipPad(a, b, pad = null) {
| const maxLen = Math.max(a.length, b.length);
for (let i = 0; i < maxLen; i++) {
yield [i < a.length ? a[i] : pad, i < b.length ? b[i] : pad];
}
}
| const assert = require('assert');
const r = [...zipPad([1, 2, 3], ['a', 'b'], 0)];
assert.deepStrictEqual(r, [[1, 'a'], [2, 'b'], [3, 0]]);
const r2 = [...zipPad([1], [4, 5, 6])];
assert.deepStrictEqual(r2, [[1, 4], [null, 5], [null, 6]]);
console.log('Task 46 passed');
| assert.deepStrictEqual([...zipPad([], [])], []);
assert.deepStrictEqual([...zipPad([1], [])], [[1, null]]);
assert.deepStrictEqual([...zipPad([], [1], 'x')], [['x', 1]]);
assert.deepStrictEqual([...zipPad([1, 2], [3, 4])], [[1, 3], [2, 4]]);
assert.deepStrictEqual([...zipPad([1], [2, 3], -1)], [[1, 2], [-1, 3]]);
conso... | low_context |
47 | devbench-low-context | javascript | function customStringify(obj, numPrefix = '#') {
return JSON.stringify(obj, (key, value) => {
| if (key.startsWith('_')) return undefined;
if (typeof value === 'number') return numPrefix + value;
return value;
});
}
| const assert = require('assert');
assert.strictEqual(customStringify({a: 1, _b: 2, c: 'hi'}), '{"a":"#1","c":"hi"}');
assert.strictEqual(customStringify({x: 3}, '!'), '{"x":"!3"}');
assert.strictEqual(customStringify({_secret: 99, visible: 0}), '{"visible":"#0"}');
console.log('Task 47 passed');
| assert.strictEqual(customStringify({}), '{}');
assert.strictEqual(customStringify({a: 'text'}), '{"a":"text"}');
assert.strictEqual(customStringify({n: 42}), '{"n":"#42"}');
assert.strictEqual(customStringify({_x: 1, _y: 2}), '{}');
assert.strictEqual(customStringify({a: -3.14}), '{"a":"#-3.14"}');
assert.strictEqual(c... | low_context |
48 | devbench-low-context | javascript | function guardedObject(init) {
const log = [];
const proxy = new Proxy({...init}, {
deleteProperty(target, prop) {
| log.push(prop);
if (prop.startsWith('protected_')) return false;
delete target[prop];
return true;
}
});
return { proxy, log };
}
| const assert = require('assert');
const { proxy: p, log } = guardedObject({ a: 1, protected_x: 2, b: 3 });
delete p.a;
assert.strictEqual(p.a, undefined);
delete p.protected_x;
assert.strictEqual(p.protected_x, 2); // protected — not deleted
delete p.b;
assert.deepStrictEqual(log, ['a', 'protected_x', 'b']);
assert.str... | const { proxy: q, log: l2 } = guardedObject({ protected_a: 10, c: 20 });
delete q.c;
assert.strictEqual(q.c, undefined);
delete q.protected_a;
assert.strictEqual(q.protected_a, 10);
assert.deepStrictEqual(l2, ['c', 'protected_a']);
const { proxy: q2, log: l3 } = guardedObject({});
delete q2.nonexistent;
assert.deepStri... | low_context |
49 | devbench-low-context | javascript | class ReverseEmitter {
constructor() { this._events = {}; }
on(evt, fn) {
(this._events[evt] = this._events[evt] || []).push(fn);
return this;
}
| emit(evt, ...args) {
const fns = (this._events[evt] || []).slice().reverse();
for (const fn of fns) {
if (fn(...args) === false) break;
}
}
}
| const assert = require('assert');
const results = [];
const em = new ReverseEmitter();
em.on('test', () => results.push('first'));
em.on('test', () => results.push('second'));
em.on('test', () => results.push('third'));
em.emit('test');
// REVERSE order: third, second, first
assert.deepStrictEqual(results, ['third', 's... | const r2 = [];
const em2 = new ReverseEmitter();
em2.on('x', () => { r2.push('a'); return false; });
em2.on('x', () => r2.push('b'));
em2.on('x', () => { r2.push('c'); });
em2.emit('x');
// Reverse: c, b, then a returns false — stops after a
assert.deepStrictEqual(r2, ['c', 'b', 'a']);
// But if middle returns false:
c... | low_context |
50 | devbench-low-context | javascript | const _data = new WeakMap();
const _access = new WeakMap();
class Vault {
constructor(secrets) {
_data.set(this, {...secrets});
_access.set(this, {});
}
| get(key) {
const d = _data.get(this);
if (!(key in d)) return undefined;
const acc = _access.get(this);
acc[key] = (acc[key] || 0) + 1;
return d[key];
}
accessCount(key) { return (_access.get(this) || {})[key] || 0; }
}
| const assert = require('assert');
const v = new Vault({ pin: 1234, code: 'abc' });
assert.strictEqual(v.get('pin'), 1234);
assert.strictEqual(v.get('pin'), 1234);
assert.strictEqual(v.get('code'), 'abc');
assert.strictEqual(v.accessCount('pin'), 2);
assert.strictEqual(v.accessCount('code'), 1);
assert.strictEqual(v.acc... | const v2 = new Vault({ x: 10 });
assert.strictEqual(v2.get('x'), 10);
assert.strictEqual(v2.accessCount('x'), 1);
v2.get('x'); v2.get('x'); v2.get('x');
assert.strictEqual(v2.accessCount('x'), 4);
assert.strictEqual(v2.get('missing'), undefined);
assert.strictEqual(v2.accessCount('missing'), 0);
// Separate instances d... | low_context |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.