Gemini 4 Argon coding test

Prompt to give the model

Implement pool.ts exporting async function pool<T>(tasks: Array<() => Promise<T>>, limit: number): Promise<PromiseSettledResult<T>[]>. Start tasks lazily, run at most limit simultaneously, keep input order, settle promise rejection and synchronous throws without stopping other tasks. Empty input returns []. Reject non-positive/non-integer limits with RangeError even for empty input. Use no dependencies. Return only pool.ts. Do not modify the supplied checks.

Input / starter files

// Input: delays [30, 5, 15] ms; limit 2.
// Implementation file: pool.ts

Save these checks before testing

// Save as pool.check.ts (Node 22+)
import assert from 'node:assert/strict';
import { pool } from './pool.ts';
let active = 0, peak = 0;
const tasks = [30, 5, 15].map((ms, i) => async () => {
 active++; peak = Math.max(peak, active);
 await new Promise(r => setTimeout(r, ms));
 active--; return i;
});
assert.deepEqual(await pool(tasks, 2), [0,1,2].map(value => ({status:'fulfilled', value})));
assert.equal(peak, 2);
const rejected = await pool([() => { throw new Error('sync'); }, () => Promise.reject('async'), async () => 7], 1);
assert.deepEqual(rejected.map(r => r.status), ['rejected','rejected','fulfilled']);
assert.deepEqual(rejected[2], {status:'fulfilled', value:7});
assert.deepEqual(await pool([], 2), []);
for (const limit of [0, -1, 1.5, NaN, Infinity]) {
 await assert.rejects(async () => pool([], limit), RangeError);
}
console.log('pool: all assertions passed');

Run locally

npx --yes --package tsx@4.21.0 tsx pool.check.ts

Prompt to give the model

Fix useSearch.ts below. Keep the API useSearch(query, search), where search(q) returns Promise<string[]>. Only the latest query may update state. Clear results and error for blank/whitespace queries; suppress stale success AND rejection; set error to the current rejection message; suppress updates after unmount. search is stable. Return an object with items and error fields; error is initially null. Return only useSearch.ts; do not change checks.

Input / starter files

// Save as useSearch.ts — intentionally broken starter
import { useEffect, useState } from 'react';
export function useSearch(query: string, search: (q: string) => Promise<string[]>) {
 const [items, setItems] = useState<string[]>([]);
 const [error, setError] = useState<string | null>(null);
 useEffect(() => { search(query).then(setItems).catch(e => setError(e.message)); }, [query, search]);
 return {items, error};
}

Save these checks before testing

// Save as race.check.test.tsx in a fresh npm directory.
// @vitest-environment jsdom
import { afterEach, expect, test, vi } from 'vitest';
import { act, cleanup, renderHook } from '@testing-library/react';
import { useSearch } from './useSearch';
afterEach(cleanup);
const deferred = () => {
 let resolve!: (v:string[])=>void;
 let reject!: (e:Error)=>void;
 const promise = new Promise<string[]>((a,b)=>{resolve=a;reject=b});
 return {promise,resolve,reject};
};
test('latest request, blank query, rejection and unmount', async () => {
 const a=deferred(), b=deferred(), c=deferred(), d=deferred();
 const pending: Record<string, ReturnType<typeof deferred>> = {a,b,c,d};
 const search=vi.fn((q:string) => pending[q].promise);
 const {result, rerender, unmount}=renderHook(({q})=>useSearch(q,search), {initialProps:{q:'a'}});
 rerender({q:'b'});
 await act(async()=>b.resolve(['B']));
 await act(async()=>a.resolve(['A']));
 expect(result.current.items).toEqual(['B']);
 rerender({q:'c'}); rerender({q:'  '});
 await act(async()=>c.reject(new Error('stale')));
 expect(result.current).toEqual({items:[],error:null});
 expect(search).toHaveBeenCalledTimes(3);
 rerender({q:'d'});
 await act(async()=>d.reject(new Error('offline')));
 expect(result.current.error).toBe('offline');
 const e=deferred();
 const next=()=>e.promise;
 const h=renderHook(()=>useSearch('e',next));
 h.unmount(); await act(async()=>e.resolve(['late']));
 unmount();
});

Run locally

npm init -y
npm install --save-exact react@19.2.1 react-dom@19.2.1
npm install --save-dev --save-exact vitest@3.2.4 jsdom@26.1.0 @testing-library/react@16.3.0
npx vitest run race.check.test.tsx

Prompt to give the model

Write summarize.py for Python 3.11+, standard library only. Read UTF-8 CSV from stdin: name,amount,currency. Sum Decimal amounts by currency, trim fields, uppercase currencies, accept only USD/EUR. Skip rows with missing/blank fields, unsupported currency, malformed/non-finite amounts or more than 2 decimal places. Support quoted commas in names. Output JSON with sorted currency keys and string values with two decimals, plus skipped count: totals (currency-to-amount object) and skipped (integer). Empty CSV gives empty totals and skipped 0. Do not use float. Return only summarize.py.

Input / starter files

name,amount,currency
"Doe, Jane",0.10,usd
Bob,0.20,USD
Eve,-1.00,EUR
X,NaN,USD
Y,2.345,USD
Z,10,GBP
Missing,,USD

Save these checks before testing

# Save as csv_check.py next to summarize.py
import json, subprocess, sys
sample = 'name,amount,currency\n"Doe, Jane",0.10,usd\nBob,0.20,USD\nEve,-1.00,EUR\nX,NaN,USD\nY,2.345,USD\nZ,10,GBP\nMissing,,USD\n'
def run(data):
 p = subprocess.run([sys.executable, 'summarize.py'], input=data, text=True, capture_output=True, timeout=5, check=True)
 return json.loads(p.stdout)
assert run(sample) == {'totals': {'EUR':'-1.00', 'USD':'0.30'}, 'skipped':4}
assert run('name,amount,currency\n') == {'totals':{}, 'skipped':0}
assert run('name,amount,currency\nA,Infinity,USD\n') == {'totals':{}, 'skipped':1}
print('csv: all assertions passed')

Run locally

python csv_check.py

Prompt to give the model

Refactor the three TypeScript files below. Replace displayName with firstName and lastName in internal User. Export getDisplayName(user): string from user.ts; trim names and join nonempty parts with one space. Update renderUser and toPublicUser, preserving their names, return types and public output object with id and name fields. Remove internal displayName references. No any, type assertions or dependencies. Return all three full files. Do not change checks.

Input / starter files

// user.ts
export type User = {id: string; displayName: string};
// view.ts
import type { User } from './user';
export const renderUser = (user: User): string => user.displayName;
// api.ts
import type { User } from './user';
export const toPublicUser = (user: User): {id: string; name: string} => ({id: user.id, name: user.displayName});

Save these checks before testing

// Save as refactor.check.ts
import assert from 'node:assert/strict';
import { getDisplayName, type User } from './user';
import { renderUser } from './view';
import { toPublicUser } from './api';
const u: User = {id:'u1', firstName:' Ada ', lastName:' Lovelace '};
assert.equal(getDisplayName(u), 'Ada Lovelace');
assert.equal(renderUser(u), 'Ada Lovelace');
assert.deepEqual(toPublicUser(u), {id:'u1', name:'Ada Lovelace'});
assert.equal(getDisplayName({...u, firstName:' ', lastName:' Ng '}), 'Ng');
assert.equal(getDisplayName({...u, firstName:'', lastName:''}), '');
console.log('refactor: all assertions passed');

Run locally

npx --yes --package typescript@5.9.3 tsc --noEmit --strict --target ES2022 --module ESNext --moduleResolution bundler user.ts view.ts api.ts
npx --yes --package tsx@4.21.0 tsx refactor.check.ts