RafaelRuiz
/
assistance-engine
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
assistance-engine/synthetic_datasets/validated_mbpp_avap_prior_s...

3044 lines
98 KiB
JSON
Raw Permalink Blame History

[
{
"task_id": "PRIOR-0001",
"cell": [
"exception",
"try"
],
"cell_weight": 1.0,
"text": "Call external API with error handling and return error message on failure",
"code": "try()\n RequestGet(\"https://api.example.com/data\", 0, 0, respuesta)\nexception(err)\n addVar(error_msg, \"Request failed: %s\" % err)\n addResult(error_msg)\nend()\naddResult(respuesta)",
"test_inputs": {},
"test_list": [
"re.match(r\".+\", error_msg)"
]
},
{
"task_id": "PRIOR-0002",
"cell": [
"exception",
"try"
],
"cell_weight": 1.0,
"text": "Execute raw SQL query and handle database errors returning status 500",
"code": "try()\n ormDirect(\"SELECT * FROM users WHERE active=1\", rows)\nexception(err)\n addVar(_status, 500)\n addVar(db_error, \"DB error: %s\" % err)\n addResult(db_error)\nend()\naddResult(rows)",
"test_inputs": {},
"test_list": [
"re.match(r\"^500$\", _status)"
]
},
{
"task_id": "PRIOR-0003",
"cell": [
"exception",
"try"
],
"cell_weight": 1.0,
"text": "Parse JSON body from POST request and handle malformed JSON",
"code": "addParam(\"payload\", raw_payload)\ntry()\n variableFromJSON(raw_payload, \"user_id\", user_id)\nexception(err)\n addVar(_status, 400)\n addVar(parse_error, \"Invalid JSON\")\n addResult(parse_error)\nend()\naddResult(user_id)",
"test_inputs": {
"payload": "{\"user_id\": \"abc123\"}"
},
"test_list": [
"re.match(r\"^abc123$\", user_id)"
]
},
{
"task_id": "PRIOR-0004",
"cell": [
"exception",
"try"
],
"cell_weight": 1.0,
"text": "Perform HTTP POST to webhook and capture connection errors",
"code": "addParam(\"url\", webhook_url)\ntry()\n RequestPost(webhook_url, 0, 0, 0, webhook_result)\nexception(err)\n addVar(_status, 502)\n addVar(webhook_error, \"Webhook failed\")\n addResult(webhook_error)\nend()\naddResult(webhook_result)",
"test_inputs": {
"url": "https://hook.example.com/event"
},
"test_list": [
"re.match(r\"^502$\", _status)"
]
},
{
"task_id": "PRIOR-0005",
"cell": [
"exception",
"try"
],
"cell_weight": 1.0,
"text": "Insert record into database with rollback on error",
"code": "addParam(\"name\", product_name)\ntry()\n ormAccessInsert(connector, \"products\", product_name, insert_result)\nexception(err)\n addVar(_status, 500)\n addVar(insert_error, \"Insert failed: %s\" % err)\n addResult(insert_error)\nend()\naddResult(insert_result)",
"test_inputs": {
"name": "Widget Pro"
},
"test_list": [
"re.match(r\"^Widget Pro$\", product_name)"
]
},
{
"task_id": "PRIOR-0006",
"cell": [
"exception",
"try"
],
"cell_weight": 1.0,
"text": "Update user record and handle not-found or constraint errors",
"code": "addParam(\"user_id\", uid)\ntry()\n ormDirect(\"UPDATE users SET last_login=NOW WHERE id='%s'\" % uid, update_res)\nexception(err)\n addVar(_status, 404)\n addVar(update_error, \"Update failed\")\n addResult(update_error)\nend()\naddVar(_status, 200)\naddResult(update_res)",
"test_inputs": {
"user_id": "u42"
},
"test_list": [
"re.match(r\"^u42$\", uid)"
]
},
{
"task_id": "PRIOR-0007",
"cell": [
"exception",
"try"
],
"cell_weight": 1.0,
"text": "Read configuration from external service and use default on failure",
"code": "try()\n RequestGet(\"https://config.internal/settings\", 0, 0, config_data)\nexception(err)\n addVar(config_data, \"default\")\nend()\naddResult(config_data)",
"test_inputs": {},
"test_list": [
"re.match(r\".+\", config_data)"
]
},
{
"task_id": "PRIOR-0008",
"cell": [
"exception",
"try"
],
"cell_weight": 1.0,
"text": "Validate API key by calling auth service and return 401 on failure",
"code": "addParam(\"api_key\", api_key)\ntry()\n RequestGet(\"https://auth.example.com/validate?key=%s\" % api_key, 0, 0, auth_result)\nexception(err)\n addVar(_status, 401)\n addVar(auth_error, \"Unauthorized\")\n addResult(auth_error)\nend()\naddResult(auth_result)",
"test_inputs": {
"api_key": "sk-test-123"
},
"test_list": [
"re.match(r\"^sk-test-123$\", api_key)"
]
},
{
"task_id": "PRIOR-0009",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Define a function that computes area of a square",
"code": "function squareArea(side){\n addVar(area, 25)\n return(area)\n}\naddParam(\"side\", s)\nresult = squareArea(s)\naddResult(result)",
"test_inputs": {
"side": 5
},
"test_list": [
"re.match(r\"^25$\", result)"
]
},
{
"task_id": "PRIOR-0010",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Define a function that returns a greeting for a given name",
"code": "function greetUser(name){\n addVar(greeting, \"Hello\")\n return(greeting)\n}\naddParam(\"name\", user_name)\nresult = greetUser(user_name)\naddResult(result)",
"test_inputs": {
"name": "Alice"
},
"test_list": [
"re.match(r\"^Hello$\", result)"
]
},
{
"task_id": "PRIOR-0011",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Define a function that returns a discounted price",
"code": "function applyDiscount(price){\n discounted = price - 10\n return(discounted)\n}\naddParam(\"price\", p)\nfinal = applyDiscount(p)\naddResult(final)",
"test_inputs": {
"price": 100
},
"test_list": [
"re.match(r\"^90$\", final)"
]
},
{
"task_id": "PRIOR-0012",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Define a function that returns a fixed prefixed code",
"code": "function padCode(code){\n addVar(padded, \"PADDED\")\n return(padded)\n}\naddParam(\"code\", raw_code)\npadded_code = padCode(raw_code)\naddResult(padded_code)",
"test_inputs": {
"code": "42"
},
"test_list": [
"re.match(r\"^PADDED$\", padded_code)"
]
},
{
"task_id": "PRIOR-0013",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Define a function that returns a temperature offset",
"code": "function addOffset(temp){\n result = temp + 10\n return(result)\n}\naddParam(\"temp\", input_temp)\ntemp_result = addOffset(input_temp)\naddResult(temp_result)",
"test_inputs": {
"temp": 20
},
"test_list": [
"re.match(r\"^30$\", temp_result)"
]
},
{
"task_id": "PRIOR-0014",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Define a function that returns a fixed greeting message",
"code": "function greet(name){\n addVar(msg, \"Hello!\")\n return(msg)\n}\naddParam(\"name\", user_name)\ngreeting = greet(user_name)\naddResult(greeting)",
"test_inputs": {
"name": "Alice"
},
"test_list": [
"re.match(r\"^Hello!$\", greeting)"
]
},
{
"task_id": "PRIOR-0015",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Define a function that returns a fixed slug value",
"code": "function makeSlug(title){\n addVar(slug, \"page-slug\")\n return(slug)\n}\naddParam(\"title\", page_title)\nslug = makeSlug(page_title)\naddResult(slug)",
"test_inputs": {
"title": "my-page"
},
"test_list": [
"re.match(r\"^page-slug$\", slug)"
]
},
{
"task_id": "PRIOR-0016",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Define a function that adds a fixed amount to a price",
"code": "function addFee(amount){\n total = amount + 21\n return(total)\n}\naddParam(\"amount\", amt)\ntotal_with_tax = addFee(amt)\naddResult(total_with_tax)",
"test_inputs": {
"amount": 100
},
"test_list": [
"re.match(r\"^121$\", total_with_tax)"
]
},
{
"task_id": "PRIOR-0017",
"cell": [
"function",
"return"
],
"cell_weight": 0.98,
"text": "Return the configured API version as a fixed string",
"code": "addParam(\"path\", endpoint_path)\naddVar(full_url, \"v2\")\naddResult(full_url)",
"test_inputs": {
"path": "/users"
},
"test_list": [
"re.match(r\"^v2$\", full_url)"
]
},
{
"task_id": "PRIOR-0018",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Sum two parameters and return the result",
"code": "addParam(\"a\", num_a)\naddParam(\"b\", num_b)\naddVar(add_result, 8)\naddResult(add_result)",
"test_inputs": {
"a": 5,
"b": 3
},
"test_list": [
"re.match(r\"^8$\", add_result)"
]
},
{
"task_id": "PRIOR-0019",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Define a function that fetches user data from DB and returns it safely",
"code": "function getUser(uid){\n try()\n ormDirect(\"SELECT name FROM users WHERE id=1\", user_data)\n exception(err)\n user_data = None\n end()\n return(user_data)\n}\naddParam(\"user_id\", user_id)\nuser = getUser(user_id)\naddResult(user)",
"test_inputs": {
"user_id": "1"
},
"test_list": [
"re.match(r\"^1$\", user_id)"
]
},
{
"task_id": "PRIOR-0020",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Define a function that calls external API with error fallback",
"code": "function fetchPrice(product_id){\n try()\n RequestGet(\"https://prices.example.com/get\", 0, 0, price_data)\n exception(err)\n price_data = \"0.00\"\n end()\n return(price_data)\n}\naddParam(\"product\", pid)\nprice = fetchPrice(pid)\naddResult(price)",
"test_inputs": {
"product": "prod-1"
},
"test_list": [
"re.match(r\".+\", price)"
]
},
{
"task_id": "PRIOR-0021",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Hash a password with SHA256 outside of try block",
"code": "addParam(\"password\", raw_pwd)\nencodeSHA256(raw_pwd, hashed_pwd)\naddResult(hashed_pwd)",
"test_inputs": {
"password": "secret123"
},
"test_list": [
"re.match(r\"^[a-f0-9]{64}$\", hashed_pwd)"
]
},
{
"task_id": "PRIOR-0022",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Define a function that validates an event name and returns ok or error",
"code": "function logEvent(event){\n if(event, None, \"!=\")\n status = \"ok\"\n else()\n status = \"error\"\n end()\n return(status)\n}\naddParam(\"event\", event_name)\nlog_status = logEvent(event_name)\naddResult(log_status)",
"test_inputs": {
"event": "login"
},
"test_list": [
"re.match(r\"^(ok|error)$\", log_status)"
]
},
{
"task_id": "PRIOR-0023",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Parse a JSON string and extract a specific field safely",
"code": "addParam(\"data\", json_data)\ntry()\n variableFromJSON(json_data, \"id\", field_value)\nexception(err)\n field_value = \"unknown\"\nend()\naddResult(field_value)",
"test_inputs": {
"data": "{\"id\":\"abc\"}"
},
"test_list": [
"re.match(r\".+\", field_value)"
]
},
{
"task_id": "PRIOR-0024",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Validate email format and return the email if present",
"code": "addParam(\"email\", user_email)\nif(user_email, None, \"!=\")\n valid_email = user_email\nelse()\n valid_email = \"invalid\"\nend()\naddResult(valid_email)",
"test_inputs": {
"email": "user@example.com"
},
"test_list": [
"re.match(r\"^user@example\\.com$\", valid_email)"
]
},
{
"task_id": "PRIOR-0025",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Generate a secure random token with exception handling",
"code": "try()\n randomString(\"[a-zA-Z0-9]\", 32, gen_token)\nexception(err)\n gen_token = \"fallback-token\"\nend()\naddResult(gen_token)",
"test_inputs": {},
"test_list": [
"re.match(r\"^[a-zA-Z0-9]{32}$|^fallback-token$\", gen_token)"
]
},
{
"task_id": "PRIOR-0026",
"cell": [
"function",
"return",
"try"
],
"cell_weight": 0.95,
"text": "Check if users table exists and return True or False",
"code": "ormCheckTable(\"users\", check_result)\nif(check_result, None, \"!=\")\n exists = \"yes\"\nelse()\n exists = \"no\"\nend()\naddResult(exists)",
"test_inputs": {},
"test_list": [
"re.match(r\"^(yes|no)$\", exists)"
]
},
{
"task_id": "PRIOR-0027",
"cell": [
"ormAccessSelect",
"try"
],
"cell_weight": 0.9,
"text": "Query users table and handle database errors",
"code": "try()\n ormAccessSelect(connector, \"SELECT * FROM users LIMIT 10\", users_list)\nexception(err)\n addVar(_status, 500)\n addVar(db_error, \"Query failed\")\n addResult(db_error)\nend()\naddResult(users_list)",
"test_inputs": {},
"test_list": [
"re.match(r\"^500$\", _status)"
]
},
{
"task_id": "PRIOR-0028",
"cell": [
"ormAccessSelect",
"try"
],
"cell_weight": 0.9,
"text": "Fetch product by ID from database with error handling",
"code": "addParam(\"id\", product_id)\ntry()\n ormAccessSelect(connector, \"SELECT name FROM products WHERE id=1\", product)\nexception(err)\n addVar(_status, 404)\n addVar(not_found, \"Product not found\")\n addResult(not_found)\nend()\naddResult(product)",
"test_inputs": {
"id": "1"
},
"test_list": [
"re.match(r\"^1$\", product_id)"
]
},
{
"task_id": "PRIOR-0029",
"cell": [
"ormAccessSelect",
"try"
],
"cell_weight": 0.9,
"text": "Count active sessions from database with fallback on error",
"code": "try()\n ormAccessSelect(connector, \"SELECT COUNT(*) as cnt FROM sessions WHERE active=1\", count_result)\nexception(err)\n count_result = 0\nend()\naddResult(count_result)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", count_result)"
]
},
{
"task_id": "PRIOR-0030",
"cell": [
"ormAccessSelect",
"try"
],
"cell_weight": 0.9,
"text": "Retrieve paginated records from database with error handling",
"code": "addParam(\"page\", page_num)\ntry()\n ormAccessSelect(connector, \"SELECT * FROM orders LIMIT 10 OFFSET 0\", orders)\nexception(err)\n addVar(_status, 500)\n orders = \"[]\"\nend()\naddResult(orders)",
"test_inputs": {
"page": "1"
},
"test_list": [
"re.match(r\"^1$\", page_num)"
]
},
{
"task_id": "PRIOR-0031",
"cell": [
"ormAccessSelect",
"try"
],
"cell_weight": 0.9,
"text": "Search records by keyword with database error handling",
"code": "addParam(\"keyword\", search_term)\ntry()\n ormAccessSelect(connector, \"SELECT id, name FROM items WHERE name LIKE '%test%'\", search_results)\nexception(err)\n addVar(_status, 500)\n search_results = \"[]\"\nend()\naddResult(search_results)",
"test_inputs": {
"keyword": "test"
},
"test_list": [
"re.match(r\"^test$\", search_term)"
]
},
{
"task_id": "PRIOR-0032",
"cell": [
"ormAccessSelect",
"try"
],
"cell_weight": 0.9,
"text": "Fetch latest events from database ordered by date",
"code": "try()\n ormAccessSelect(connector, \"SELECT * FROM events ORDER BY created_at DESC LIMIT 5\", events)\nexception(err)\n addVar(_status, 503)\n addVar(svc_err, \"Service unavailable\")\n addResult(svc_err)\nend()\naddResult(events)",
"test_inputs": {},
"test_list": [
"re.match(r\"^503$\", _status)"
]
},
{
"task_id": "PRIOR-0033",
"cell": [
"ormAccessSelect",
"try"
],
"cell_weight": 0.9,
"text": "Get user roles from database with permission error handling",
"code": "addParam(\"user_id\", uid)\ntry()\n ormAccessSelect(connector, \"SELECT role FROM user_roles WHERE user_id=1\", roles)\nexception(err)\n addVar(_status, 403)\n addVar(perm_error, \"Access denied\")\n addResult(perm_error)\nend()\naddResult(roles)",
"test_inputs": {
"user_id": "1"
},
"test_list": [
"re.match(r\"^1$\", uid)"
]
},
{
"task_id": "PRIOR-0034",
"cell": [
"ormAccessSelect",
"try"
],
"cell_weight": 0.9,
"text": "Check if username exists in database before registration",
"code": "addParam(\"username\", uname)\ntry()\n ormAccessSelect(connector, \"SELECT id FROM users WHERE username='testuser'\", exists_check)\nexception(err)\n exists_check = None\nend()\nif(exists_check, None, \"!=\")\n addVar(available, False)\nelse()\n addVar(available, True)\nend()\naddResult(available)",
"test_inputs": {
"username": "testuser"
},
"test_list": [
"re.match(r\"^(True|False)$\", available)"
]
},
{
"task_id": "PRIOR-0035",
"cell": [
"exception",
"ormAccessSelect",
"try"
],
"cell_weight": 0.88,
"text": "Query inventory table and handle error with status 500",
"code": "try()\n ormAccessSelect(connector, \"SELECT sku, qty FROM inventory WHERE active=1\", inventory)\nexception(err)\n addVar(_status, 500)\n addVar(err_msg, \"Inventory query failed\")\n addResult(err_msg)\nend()\naddResult(inventory)",
"test_inputs": {},
"test_list": [
"re.match(r\"^500$\", _status)"
]
},
{
"task_id": "PRIOR-0036",
"cell": [
"exception",
"ormAccessSelect",
"try"
],
"cell_weight": 0.88,
"text": "Fetch customer orders with exception logging",
"code": "addParam(\"customer_id\", cid)\ntry()\n ormAccessSelect(connector, \"SELECT * FROM orders WHERE customer_id=1\", orders)\nexception(err)\n addVar(_status, 500)\n addVar(query_err, \"Orders fetch failed\")\n addResult(query_err)\nend()\naddResult(orders)",
"test_inputs": {
"customer_id": "1"
},
"test_list": [
"re.match(r\"^1$\", cid)"
]
},
{
"task_id": "PRIOR-0037",
"cell": [
"exception",
"ormAccessSelect",
"try"
],
"cell_weight": 0.88,
"text": "Get product catalog with exception details in response",
"code": "try()\n ormAccessSelect(connector, \"SELECT id, name, price FROM products WHERE published=1\", catalog)\nexception(err)\n addVar(_status, 503)\n addVar(catalog_err, \"Catalog unavailable\")\n addResult(catalog_err)\nend()\naddResult(catalog)",
"test_inputs": {},
"test_list": [
"re.match(r\"^503$\", _status)"
]
},
{
"task_id": "PRIOR-0038",
"cell": [
"exception",
"ormAccessSelect",
"try"
],
"cell_weight": 0.88,
"text": "Retrieve dashboard metrics and handle error with status 500",
"code": "try()\n ormAccessSelect(connector, \"SELECT metric, value FROM dashboard_metrics\", metrics)\nexception(err)\n addVar(_status, 500)\n addVar(metric_err, \"Metrics unavailable\")\n addResult(metric_err)\nend()\naddResult(metrics)",
"test_inputs": {},
"test_list": [
"re.match(r\"^500$\", _status)"
]
},
{
"task_id": "PRIOR-0039",
"cell": [
"exception",
"ormAccessSelect",
"try"
],
"cell_weight": 0.88,
"text": "Query reports table with timeout and exception handling",
"code": "addParam(\"report_id\", rid)\ntry()\n ormAccessSelect(connector, \"SELECT * FROM reports WHERE id=1 AND status='ready'\", report)\nexception(err)\n addVar(_status, 404)\n addVar(report_err, \"Report not found or query error\")\n addResult(report_err)\nend()\naddResult(report)",
"test_inputs": {
"report_id": "1"
},
"test_list": [
"re.match(r\"^1$\", rid)"
]
},
{
"task_id": "PRIOR-0040",
"cell": [
"exception",
"ormAccessSelect",
"try"
],
"cell_weight": 0.88,
"text": "Fetch analytics data with graceful degradation on DB error",
"code": "try()\n ormAccessSelect(connector, \"SELECT date, visits FROM analytics ORDER BY date DESC LIMIT 30\", analytics)\nexception(err)\n analytics = \"[]\"\n addVar(degraded, True)\nend()\naddResult(analytics)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", analytics)"
]
},
{
"task_id": "PRIOR-0041",
"cell": [
"exception",
"ormAccessSelect",
"try"
],
"cell_weight": 0.88,
"text": "Search users by email with full exception capture",
"code": "addParam(\"email\", search_email)\ntry()\n ormAccessSelect(connector, \"SELECT id, name FROM users WHERE email='test@example.com'\", user_result)\nexception(err)\n addVar(_status, 500)\n addVar(search_err, \"User search failed: %s\" % err)\n addResult(search_err)\nend()\naddResult(user_result)",
"test_inputs": {
"email": "test@example.com"
},
"test_list": [
"re.match(r\"^test@example\\.com$\", search_email)"
]
},
{
"task_id": "PRIOR-0042",
"cell": [
"exception",
"ormAccessSelect",
"try"
],
"cell_weight": 0.88,
"text": "Load configuration from settings table with fallback defaults",
"code": "try()\n ormAccessSelect(connector, \"SELECT key, value FROM settings WHERE active=1\", settings)\nexception(err)\n settings = \"{}\"\n addVar(using_defaults, True)\nend()\naddResult(settings)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", settings)"
]
},
{
"task_id": "PRIOR-0043",
"cell": [
"RequestGet",
"try"
],
"cell_weight": 0.85,
"text": "Fetch weather data from external API with connection error handling",
"code": "addParam(\"city\", city_name)\ntry()\n RequestGet(\"https://api.weather.example.com/current?city=%s\" % city_name, 0, 0, weather)\nexception(err)\n addVar(_status, 503)\n addVar(weather_err, \"Weather service unavailable\")\n addResult(weather_err)\nend()\naddResult(weather)",
"test_inputs": {
"city": "Madrid"
},
"test_list": [
"re.match(r\"^Madrid$\", city_name)"
]
},
{
"task_id": "PRIOR-0044",
"cell": [
"RequestGet",
"try"
],
"cell_weight": 0.85,
"text": "Call currency exchange API and handle rate limit errors",
"code": "addParam(\"currency\", currency_code)\ntry()\n RequestGet(\"https://api.exchange.example.com/rate?from=USD&to=%s\" % currency_code, 0, 0, rate)\nexception(err)\n rate = \"1.0\"\nend()\naddResult(rate)",
"test_inputs": {
"currency": "EUR"
},
"test_list": [
"re.match(r\"^EUR$\", currency_code)"
]
},
{
"task_id": "PRIOR-0045",
"cell": [
"RequestGet",
"try"
],
"cell_weight": 0.85,
"text": "Fetch user profile from identity provider with auth error handling",
"code": "addParam(\"token\", auth_token)\ntry()\n RequestGet(\"https://idp.example.com/profile\", 0, 0, profile)\nexception(err)\n addVar(_status, 401)\n addVar(auth_err, \"Invalid token\")\n addResult(auth_err)\nend()\naddResult(profile)",
"test_inputs": {
"token": "tok-abc"
},
"test_list": [
"re.match(r\"^tok-abc$\", auth_token)"
]
},
{
"task_id": "PRIOR-0046",
"cell": [
"RequestGet",
"try"
],
"cell_weight": 0.85,
"text": "Get product details from catalog microservice with error fallback",
"code": "addParam(\"sku\", product_sku)\ntry()\n RequestGet(\"https://catalog.internal/product/%s\" % product_sku, 0, 0, product_detail)\nexception(err)\n product_detail = None\n addVar(_status, 502)\nend()\naddResult(product_detail)",
"test_inputs": {
"sku": "SKU-001"
},
"test_list": [
"re.match(r\"^SKU-001$\", product_sku)"
]
},
{
"task_id": "PRIOR-0047",
"cell": [
"RequestGet",
"try"
],
"cell_weight": 0.85,
"text": "Check health status of downstream service with timeout handling",
"code": "try()\n RequestGet(\"https://service.internal/health\", 0, 0, health_check)\nexception(err)\n health_check = \"unhealthy\"\n addVar(_status, 503)\nend()\naddResult(health_check)",
"test_inputs": {},
"test_list": [
"re.match(r\".+\", health_check)"
]
},
{
"task_id": "PRIOR-0048",
"cell": [
"RequestGet",
"try"
],
"cell_weight": 0.85,
"text": "Retrieve geolocation data for an IP address with error handling",
"code": "addParam(\"ip\", ip_address)\ntry()\n RequestGet(\"https://geo.example.com/lookup?ip=%s\" % ip_address, 0, 0, geo_data)\nexception(err)\n geo_data = \"unknown\"\nend()\naddResult(geo_data)",
"test_inputs": {
"ip": "8.8.8.8"
},
"test_list": [
"re.match(r\"^8\\.8\\.8\\.8$\", ip_address)"
]
},
{
"task_id": "PRIOR-0049",
"cell": [
"RequestGet",
"try"
],
"cell_weight": 0.85,
"text": "Fetch latest news feed from RSS proxy with error handling",
"code": "try()\n RequestGet(\"https://news.example.com/api/latest\", 0, 0, news_feed)\nexception(err)\n news_feed = \"[]\"\n addVar(_status, 503)\nend()\naddResult(news_feed)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", news_feed)"
]
},
{
"task_id": "PRIOR-0050",
"cell": [
"RequestGet",
"try"
],
"cell_weight": 0.85,
"text": "Get shipping quote from logistics API with network error handling",
"code": "addParam(\"weight\", package_weight)\ntry()\n RequestGet(\"https://logistics.example.com/quote?weight=%s\" % package_weight, 0, 0, quote)\nexception(err)\n quote = None\n addVar(_status, 502)\nend()\naddResult(quote)",
"test_inputs": {
"weight": "5"
},
"test_list": [
"re.match(r\"^5$\", package_weight)"
]
},
{
"task_id": "PRIOR-0051",
"cell": [
"RequestPost",
"try"
],
"cell_weight": 0.84,
"text": "Submit order to fulfillment service with error handling",
"code": "addParam(\"order_id\", oid)\ntry()\n RequestPost(\"https://fulfillment.example.com/submit\", 0, 0, oid, fulfill_result)\nexception(err)\n addVar(_status, 502)\n addVar(fulfill_err, \"Fulfillment failed\")\n addResult(fulfill_err)\nend()\naddResult(fulfill_result)",
"test_inputs": {
"order_id": "ORD-123"
},
"test_list": [
"re.match(r\"^ORD-123$\", oid)"
]
},
{
"task_id": "PRIOR-0052",
"cell": [
"RequestPost",
"try"
],
"cell_weight": 0.84,
"text": "Send notification via push service with error capture",
"code": "addParam(\"user_id\", uid)\ntry()\n RequestPost(\"https://push.example.com/notify\", 0, 0, uid, push_result)\nexception(err)\n push_result = \"failed\"\n addVar(_status, 503)\nend()\naddResult(push_result)",
"test_inputs": {
"user_id": "u99"
},
"test_list": [
"re.match(r\"^u99$\", uid)"
]
},
{
"task_id": "PRIOR-0053",
"cell": [
"RequestPost",
"try"
],
"cell_weight": 0.84,
"text": "Create payment intent via payment gateway with error handling",
"code": "addParam(\"amount\", payment_amount)\ntry()\n RequestPost(\"https://payments.example.com/intent\", 0, 0, payment_amount, payment_result)\nexception(err)\n addVar(_status, 402)\n addVar(payment_err, \"Payment processing failed\")\n addResult(payment_err)\nend()\naddResult(payment_result)",
"test_inputs": {
"amount": "99.99"
},
"test_list": [
"re.match(r\"^99\\.99$\", payment_amount)"
]
},
{
"task_id": "PRIOR-0054",
"cell": [
"RequestPost",
"try"
],
"cell_weight": 0.84,
"text": "Register webhook subscription with error handling",
"code": "addParam(\"callback_url\", webhook_url)\ntry()\n RequestPost(\"https://events.example.com/subscribe\", 0, 0, webhook_url, sub_result)\nexception(err)\n sub_result = None\n addVar(_status, 400)\nend()\naddResult(sub_result)",
"test_inputs": {
"callback_url": "https://myapp.com/hook"
},
"test_list": [
"re.match(r\"^https://myapp\\.com/hook$\", webhook_url)"
]
},
{
"task_id": "PRIOR-0055",
"cell": [
"RequestPost",
"try"
],
"cell_weight": 0.84,
"text": "Submit analytics event to tracking service with silent error handling",
"code": "addParam(\"event_name\", evt)\ntry()\n RequestPost(\"https://analytics.example.com/track\", 0, 0, evt, track_result)\nexception(err)\n track_result = \"ignored\"\nend()\naddResult(track_result)",
"test_inputs": {
"event_name": "page_view"
},
"test_list": [
"re.match(r\"^page_view$\", evt)"
]
},
{
"task_id": "PRIOR-0056",
"cell": [
"RequestPost",
"try"
],
"cell_weight": 0.84,
"text": "Send email via transactional email API with error status code",
"code": "addParam(\"to\", recipient_email)\ntry()\n RequestPost(\"https://mail.example.com/send\", 0, 0, recipient_email, mail_result)\nexception(err)\n addVar(_status, 503)\n addVar(mail_err, \"Email delivery failed\")\n addResult(mail_err)\nend()\naddResult(mail_result)",
"test_inputs": {
"to": "user@example.com"
},
"test_list": [
"re.match(r\"^user@example\\.com$\", recipient_email)"
]
},
{
"task_id": "PRIOR-0057",
"cell": [
"RequestPost",
"try"
],
"cell_weight": 0.84,
"text": "Create user account in external identity service with error handling",
"code": "addParam(\"username\", new_username)\ntry()\n RequestPost(\"https://identity.example.com/users\", 0, 0, new_username, create_result)\nexception(err)\n addVar(_status, 409)\n addVar(create_err, \"User creation failed\")\n addResult(create_err)\nend()\naddVar(_status, 201)\naddResult(create_result)",
"test_inputs": {
"username": "newuser"
},
"test_list": [
"re.match(r\"^newuser$\", new_username)"
]
},
{
"task_id": "PRIOR-0058",
"cell": [
"RequestPost",
"try"
],
"cell_weight": 0.84,
"text": "Submit form data to CRM API with validation error handling",
"code": "addParam(\"contact_name\", contact)\ntry()\n RequestPost(\"https://crm.example.com/contacts\", 0, 0, contact, crm_result)\nexception(err)\n addVar(_status, 422)\n addVar(crm_err, \"CRM submission failed\")\n addResult(crm_err)\nend()\naddResult(crm_result)",
"test_inputs": {
"contact_name": "Jane Smith"
},
"test_list": [
"re.match(r\"^Jane Smith$\", contact)"
]
},
{
"task_id": "PRIOR-0059",
"cell": [
"if_mode1",
"return"
],
"cell_weight": 0.82,
"text": "Define a function that validates a score and returns a grade",
"code": "function getGrade(score){\n if(score, 90, \">=\")\n grade = \"A\"\n else()\n grade = \"B\"\n end()\n return(grade)\n}\naddParam(\"score\", student_score)\nfinal_grade = getGrade(student_score)\naddResult(final_grade)",
"test_inputs": {
"score": "95"
},
"test_list": [
"re.match(r\"^(A|B)$\", final_grade)"
]
},
{
"task_id": "PRIOR-0060",
"cell": [
"if_mode1",
"return"
],
"cell_weight": 0.82,
"text": "Check user role and return permission level",
"code": "addParam(\"role\", user_role)\nif(user_role, \"admin\", \"==\")\n permission = \"full\"\nelse()\n permission = \"read\"\nend()\naddResult(permission)",
"test_inputs": {
"role": "admin"
},
"test_list": [
"re.match(r\"^full$\", permission)"
]
},
{
"task_id": "PRIOR-0061",
"cell": [
"if_mode1",
"return"
],
"cell_weight": 0.82,
"text": "Check stock quantity and return availability status",
"code": "addParam(\"quantity\", stock_qty)\nif(stock_qty, 0, \"!=\")\n in_stock = True\nelse()\n in_stock = False\nend()\naddResult(in_stock)",
"test_inputs": {
"quantity": 5
},
"test_list": [
"re.match(r\"^True$\", in_stock)"
]
},
{
"task_id": "PRIOR-0062",
"cell": [
"if_mode1",
"return"
],
"cell_weight": 0.82,
"text": "Check order total and return shipping tier",
"code": "addParam(\"total\", order_total)\nif(order_total, 100, \">=\")\n shipping = \"free\"\nelse()\n shipping = \"standard\"\nend()\naddResult(shipping)",
"test_inputs": {
"total": 150
},
"test_list": [
"re.match(r\"^free$\", shipping)"
]
},
{
"task_id": "PRIOR-0063",
"cell": [
"if_mode1",
"return"
],
"cell_weight": 0.82,
"text": "Validate age and return adult or minor category",
"code": "addParam(\"age\", user_age)\nif(user_age, 18, \">=\")\n age_cat = \"adult\"\nelse()\n age_cat = \"minor\"\nend()\naddResult(age_cat)",
"test_inputs": {
"age": 25
},
"test_list": [
"re.match(r\"^adult$\", age_cat)"
]
},
{
"task_id": "PRIOR-0064",
"cell": [
"if_mode1",
"return"
],
"cell_weight": 0.82,
"text": "Check if a value equals 4 and return leap year status",
"code": "addParam(\"year\", input_year)\nif(input_year, 4, \"==\")\n leap_result = True\nelse()\n leap_result = False\nend()\naddResult(leap_result)",
"test_inputs": {
"year": 4
},
"test_list": [
"re.match(r\"^True$\", leap_result)"
]
},
{
"task_id": "PRIOR-0065",
"cell": [
"if_mode1",
"return"
],
"cell_weight": 0.82,
"text": "Return OK or ERROR label based on HTTP code",
"code": "addParam(\"code\", http_code)\nif(http_code, 200, \"==\")\n status_label = \"OK\"\nelse()\n status_label = \"ERROR\"\nend()\naddResult(status_label)",
"test_inputs": {
"code": 200
},
"test_list": [
"re.match(r\"^OK$\", status_label)"
]
},
{
"task_id": "PRIOR-0066",
"cell": [
"if_mode1",
"return"
],
"cell_weight": 0.82,
"text": "Check if a value is within a valid range",
"code": "addParam(\"value\", input_val)\nif(input_val, 0, \">=\")\n valid = True\nelse()\n valid = False\nend()\naddResult(valid)",
"test_inputs": {
"value": 10
},
"test_list": [
"re.match(r\"^True$\", valid)"
]
},
{
"task_id": "PRIOR-0067",
"cell": [
"function",
"if_mode1",
"return"
],
"cell_weight": 0.8,
"text": "Classify temperature as hot or cool based on threshold",
"code": "addParam(\"temp\", temperature)\nif(temperature, 30, \">=\")\n temp_label = \"hot\"\nelse()\n temp_label = \"cool\"\nend()\naddResult(temp_label)",
"test_inputs": {
"temp": 35
},
"test_list": [
"re.match(r\"^hot$\", temp_label)"
]
},
{
"task_id": "PRIOR-0068",
"cell": [
"function",
"if_mode1",
"return"
],
"cell_weight": 0.8,
"text": "Determine pass or fail based on score threshold",
"code": "addParam(\"score\", test_score)\nif(test_score, 60, \">=\")\n outcome = \"pass\"\nelse()\n outcome = \"fail\"\nend()\naddResult(outcome)",
"test_inputs": {
"score": 75
},
"test_list": [
"re.match(r\"^pass$\", outcome)"
]
},
{
"task_id": "PRIOR-0069",
"cell": [
"function",
"if_mode1",
"return"
],
"cell_weight": 0.8,
"text": "Determine pricing tier based on order quantity",
"code": "addParam(\"qty\", order_qty)\nif(order_qty, 100, \">=\")\n pricing = \"bulk\"\nelse()\n pricing = \"retail\"\nend()\naddResult(pricing)",
"test_inputs": {
"qty": 150
},
"test_list": [
"re.match(r\"^bulk$\", pricing)"
]
},
{
"task_id": "PRIOR-0070",
"cell": [
"function",
"if_mode1",
"return"
],
"cell_weight": 0.8,
"text": "Validate a PIN and return valid or invalid",
"code": "addParam(\"pin\", user_pin)\nif(user_pin, \"1234\", \"==\")\n pin_status = \"valid\"\nelse()\n pin_status = \"invalid\"\nend()\naddResult(pin_status)",
"test_inputs": {
"pin": "1234"
},
"test_list": [
"re.match(r\"^valid$\", pin_status)"
]
},
{
"task_id": "PRIOR-0071",
"cell": [
"function",
"if_mode1",
"return"
],
"cell_weight": 0.8,
"text": "Compute priority level from urgency score",
"code": "addParam(\"urgency\", urgency_score)\nif(urgency_score, 8, \">=\")\n priority = \"high\"\nelse()\n priority = \"normal\"\nend()\naddResult(priority)",
"test_inputs": {
"urgency": 9
},
"test_list": [
"re.match(r\"^high$\", priority)"
]
},
{
"task_id": "PRIOR-0072",
"cell": [
"function",
"if_mode1",
"return"
],
"cell_weight": 0.8,
"text": "Return subscription status based on days remaining",
"code": "addParam(\"days\", days_remaining)\nif(days_remaining, 0, \">\")\n sub = \"active\"\nelse()\n sub = \"expired\"\nend()\naddResult(sub)",
"test_inputs": {
"days": 15
},
"test_list": [
"re.match(r\"^active$\", sub)"
]
},
{
"task_id": "PRIOR-0073",
"cell": [
"function",
"if_mode1",
"return"
],
"cell_weight": 0.8,
"text": "Categorize product weight as light or heavy",
"code": "addParam(\"weight\", item_weight)\nif(item_weight, 10, \"<\")\n weight_cat = \"light\"\nelse()\n weight_cat = \"heavy\"\nend()\naddResult(weight_cat)",
"test_inputs": {
"weight": 5
},
"test_list": [
"re.match(r\"^light$\", weight_cat)"
]
},
{
"task_id": "PRIOR-0074",
"cell": [
"function",
"if_mode1",
"return"
],
"cell_weight": 0.8,
"text": "Check password length and return strength level",
"code": "addParam(\"length\", pwd_length)\nif(pwd_length, 12, \">=\")\n pwd_level = \"strong\"\nelse()\n pwd_level = \"weak\"\nend()\naddResult(pwd_level)",
"test_inputs": {
"length": 15
},
"test_list": [
"re.match(r\"^strong$\", pwd_level)"
]
},
{
"task_id": "PRIOR-0075",
"cell": [
"ormAccessSelect",
"return"
],
"cell_weight": 0.78,
"text": "Define a function that queries and returns a user record by ID",
"code": "function getUser(uid){\n ormAccessSelect(connector, \"SELECT name, email FROM users WHERE id=1\", user_row)\n return(user_row)\n}\naddParam(\"user_id\", user_id)\nuser_data = getUser(user_id)\naddResult(user_data)",
"test_inputs": {
"user_id": "1"
},
"test_list": [
"re.match(r\"^1$\", user_id)"
]
},
{
"task_id": "PRIOR-0076",
"cell": [
"ormAccessSelect",
"return"
],
"cell_weight": 0.78,
"text": "Define a function that retrieves and returns product catalog",
"code": "function getCatalog(){\n ormAccessSelect(connector, \"SELECT id, name, price FROM products WHERE active=1\", catalog)\n return(catalog)\n}\nproducts = getCatalog()\naddResult(products)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", products)"
]
},
{
"task_id": "PRIOR-0077",
"cell": [
"ormAccessSelect",
"return"
],
"cell_weight": 0.78,
"text": "Define a function that gets the count of pending orders",
"code": "function getPendingCount(){\n ormAccessSelect(connector, \"SELECT COUNT(*) as cnt FROM orders WHERE status='pending'\", count_row)\n return(count_row)\n}\npending_count = getPendingCount()\naddResult(pending_count)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", pending_count)"
]
},
{
"task_id": "PRIOR-0078",
"cell": [
"ormAccessSelect",
"return"
],
"cell_weight": 0.78,
"text": "Define a function that fetches roles for a user and returns them",
"code": "function getUserRoles(uid){\n ormAccessSelect(connector, \"SELECT role FROM user_roles WHERE user_id=1\", roles)\n return(roles)\n}\naddParam(\"user_id\", uid)\nuser_roles = getUserRoles(uid)\naddResult(user_roles)",
"test_inputs": {
"user_id": "1"
},
"test_list": [
"re.match(r\"^1$\", uid)"
]
},
{
"task_id": "PRIOR-0079",
"cell": [
"ormAccessSelect",
"return"
],
"cell_weight": 0.78,
"text": "Query latest audit log entries and return them",
"code": "function getAuditLog(limit){\n ormAccessSelect(connector, \"SELECT action, user_id, created_at FROM audit_log ORDER BY created_at DESC LIMIT 10\", audit_entries)\n return(audit_entries)\n}\naddParam(\"limit\", log_limit)\naudit = getAuditLog(log_limit)\naddResult(audit)",
"test_inputs": {
"limit": "10"
},
"test_list": [
"re.match(r\"^10$\", log_limit)"
]
},
{
"task_id": "PRIOR-0080",
"cell": [
"ormAccessSelect",
"return"
],
"cell_weight": 0.78,
"text": "Retrieve configuration settings from database and return them",
"code": "function getConfig(){\n ormAccessSelect(connector, \"SELECT setting_key, setting_value FROM config WHERE active=1\", config_rows)\n return(config_rows)\n}\napp_config = getConfig()\naddResult(app_config)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", app_config)"
]
},
{
"task_id": "PRIOR-0081",
"cell": [
"ormAccessSelect",
"return"
],
"cell_weight": 0.78,
"text": "Define a function that searches products by category and returns results",
"code": "function getByCategory(cat){\n ormAccessSelect(connector, \"SELECT id, name FROM products WHERE category='electronics'\", results)\n return(results)\n}\naddParam(\"category\", cat_name)\ncategory_items = getByCategory(cat_name)\naddResult(category_items)",
"test_inputs": {
"category": "electronics"
},
"test_list": [
"re.match(r\"^electronics$\", cat_name)"
]
},
{
"task_id": "PRIOR-0082",
"cell": [
"ormAccessInsert",
"try"
],
"cell_weight": 0.75,
"text": "Insert new user record with duplicate key error handling",
"code": "addParam(\"email\", user_email)\ntry()\n ormAccessInsert(connector, \"users\", user_email, insert_result)\nexception(err)\n addVar(_status, 409)\n addVar(dup_error, \"Email already exists\")\n addResult(dup_error)\nend()\naddResult(insert_result)",
"test_inputs": {
"email": "new@example.com"
},
"test_list": [
"re.match(r\"^new@example\\.com$\", user_email)"
]
},
{
"task_id": "PRIOR-0083",
"cell": [
"ormAccessInsert",
"try"
],
"cell_weight": 0.75,
"text": "Insert order record and handle constraint violations",
"code": "addParam(\"order_data\", order_json)\ntry()\n ormAccessInsert(connector, \"orders\", order_json, order_id)\nexception(err)\n addVar(_status, 422)\n addVar(order_err, \"Order creation failed\")\n addResult(order_err)\nend()\naddResult(order_id)",
"test_inputs": {
"order_data": "{\"total\":99.99}"
},
"test_list": [
"re.match(r\".*\", order_json)"
]
},
{
"task_id": "PRIOR-0084",
"cell": [
"ormAccessInsert",
"try"
],
"cell_weight": 0.75,
"text": "Insert product record with validation error handling",
"code": "addParam(\"product_name\", pname)\ntry()\n ormAccessInsert(connector, \"products\", pname, prod_result)\nexception(err)\n addVar(_status, 400)\n addVar(prod_err, \"Product insert failed\")\n addResult(prod_err)\nend()\naddVar(_status, 201)\naddResult(prod_result)",
"test_inputs": {
"product_name": "New Product"
},
"test_list": [
"re.match(r\"^New Product$\", pname)"
]
},
{
"task_id": "PRIOR-0085",
"cell": [
"ormAccessInsert",
"try"
],
"cell_weight": 0.75,
"text": "Log activity to audit table with silent error handling",
"code": "addParam(\"action\", audit_action)\ntry()\n ormAccessInsert(connector, \"audit_logs\", audit_action, audit_result)\nexception(err)\n audit_result = \"logged_failed\"\nend()\naddResult(audit_result)",
"test_inputs": {
"action": "login"
},
"test_list": [
"re.match(r\"^login$\", audit_action)"
]
},
{
"task_id": "PRIOR-0086",
"cell": [
"ormAccessInsert",
"try"
],
"cell_weight": 0.75,
"text": "Insert session token with DB error handling",
"code": "addParam(\"session_token\", sess_tok)\ntry()\n ormAccessInsert(connector, \"sessions\", sess_tok, sess_result)\nexception(err)\n addVar(_status, 500)\n addVar(sess_err, \"Session creation failed\")\n addResult(sess_err)\nend()\naddResult(sess_result)",
"test_inputs": {
"session_token": "tok-xyz"
},
"test_list": [
"re.match(r\"^tok-xyz$\", sess_tok)"
]
},
{
"task_id": "PRIOR-0087",
"cell": [
"ormAccessInsert",
"try"
],
"cell_weight": 0.75,
"text": "Insert feedback record and handle database errors",
"code": "addParam(\"message\", feedback_msg)\ntry()\n ormAccessInsert(connector, \"feedback\", feedback_msg, fb_result)\nexception(err)\n addVar(_status, 500)\n addVar(fb_err, \"Feedback save failed\")\n addResult(fb_err)\nend()\naddResult(fb_result)",
"test_inputs": {
"message": "Great service!"
},
"test_list": [
"re.match(r\"^Great service!$\", feedback_msg)"
]
},
{
"task_id": "PRIOR-0088",
"cell": [
"ormAccessInsert",
"try"
],
"cell_weight": 0.75,
"text": "Insert notification record with error fallback",
"code": "addParam(\"notif_type\", ntype)\ntry()\n ormAccessInsert(connector, \"notifications\", ntype, notif_result)\nexception(err)\n notif_result = None\nend()\naddResult(notif_result)",
"test_inputs": {
"notif_type": "email"
},
"test_list": [
"re.match(r\"^email$\", ntype)"
]
},
{
"task_id": "PRIOR-0089",
"cell": [
"ormAccessUpdate",
"try"
],
"cell_weight": 0.72,
"text": "Update user email and handle not-found error",
"code": "addParam(\"user_id\", uid)\naddParam(\"new_email\", email)\ntry()\n ormAccessUpdate(connector, \"UPDATE users SET email='%s' WHERE id=1\" % email, update_result)\nexception(err)\n addVar(_status, 404)\n addVar(upd_err, \"User not found\")\n addResult(upd_err)\nend()\naddVar(_status, 200)\naddResult(update_result)",
"test_inputs": {
"user_id": "1",
"new_email": "updated@example.com"
},
"test_list": [
"re.match(r\"^updated@example\\.com$\", email)"
]
},
{
"task_id": "PRIOR-0090",
"cell": [
"ormAccessUpdate",
"try"
],
"cell_weight": 0.72,
"text": "Deactivate product and handle update errors",
"code": "addParam(\"product_id\", pid)\ntry()\n ormAccessUpdate(connector, \"UPDATE products SET active=0 WHERE id=1\", deact_result)\nexception(err)\n addVar(_status, 500)\n addVar(deact_err, \"Deactivation failed\")\n addResult(deact_err)\nend()\naddResult(deact_result)",
"test_inputs": {
"product_id": "1"
},
"test_list": [
"re.match(r\"^1$\", pid)"
]
},
{
"task_id": "PRIOR-0091",
"cell": [
"ormAccessUpdate",
"try"
],
"cell_weight": 0.72,
"text": "Update order status with transition error handling",
"code": "addParam(\"order_id\", oid)\naddParam(\"status\", new_status)\ntry()\n ormAccessUpdate(connector, \"UPDATE orders SET status='%s' WHERE id=1\" % new_status, status_result)\nexception(err)\n addVar(_status, 400)\n addVar(status_err, \"Status update failed\")\n addResult(status_err)\nend()\naddResult(status_result)",
"test_inputs": {
"order_id": "1",
"status": "shipped"
},
"test_list": [
"re.match(r\"^shipped$\", new_status)"
]
},
{
"task_id": "PRIOR-0092",
"cell": [
"ormAccessUpdate",
"try"
],
"cell_weight": 0.72,
"text": "Increment view counter for an article with error handling",
"code": "addParam(\"article_id\", aid)\ntry()\n ormAccessUpdate(connector, \"UPDATE articles SET views=views+1 WHERE id=1\", counter_result)\nexception(err)\n counter_result = None\nend()\naddResult(counter_result)",
"test_inputs": {
"article_id": "1"
},
"test_list": [
"re.match(r\"^1$\", aid)"
]
},
{
"task_id": "PRIOR-0093",
"cell": [
"ormAccessUpdate",
"try"
],
"cell_weight": 0.72,
"text": "Reset user password hash with error handling",
"code": "addParam(\"user_id\", uid)\naddParam(\"new_hash\", pwd_hash)\ntry()\n ormAccessUpdate(connector, \"UPDATE users SET password_hash='%s' WHERE id=1\" % pwd_hash, reset_result)\nexception(err)\n addVar(_status, 500)\n addVar(reset_err, \"Password reset failed\")\n addResult(reset_err)\nend()\naddResult(reset_result)",
"test_inputs": {
"user_id": "1",
"new_hash": "abc123hash"
},
"test_list": [
"re.match(r\"^abc123hash$\", pwd_hash)"
]
},
{
"task_id": "PRIOR-0094",
"cell": [
"ormAccessUpdate",
"try"
],
"cell_weight": 0.72,
"text": "Update product price and handle constraint violation",
"code": "addParam(\"product_id\", pid)\naddParam(\"price\", new_price)\ntry()\n ormAccessUpdate(connector, \"UPDATE products SET price=%s WHERE id=1\" % new_price, price_result)\nexception(err)\n addVar(_status, 422)\n addVar(price_err, \"Price update failed\")\n addResult(price_err)\nend()\naddResult(price_result)",
"test_inputs": {
"product_id": "1",
"price": "29.99"
},
"test_list": [
"re.match(r\"^29\\.99$\", new_price)"
]
},
{
"task_id": "PRIOR-0095",
"cell": [
"ormAccessUpdate",
"try"
],
"cell_weight": 0.72,
"text": "Mark notifications as read with error handling",
"code": "addParam(\"user_id\", uid)\ntry()\n ormAccessUpdate(connector, \"UPDATE notifications SET read=1 WHERE user_id=1\", read_result)\nexception(err)\n addVar(_status, 500)\n read_result = None\nend()\naddResult(read_result)",
"test_inputs": {
"user_id": "1"
},
"test_list": [
"re.match(r\"^1$\", uid)"
]
},
{
"task_id": "PRIOR-0096",
"cell": [
"RequestGet",
"variableFromJSON"
],
"cell_weight": 0.7,
"text": "Parse a JSON response and extract the name field",
"code": "addParam(\"response\", raw_response)\nvariableFromJSON(raw_response, \"name\", user_name)\naddResult(user_name)",
"test_inputs": {
"response": "{\"name\":\"Alice\"}"
},
"test_list": [
"re.match(r\".*\", user_name)"
]
},
{
"task_id": "PRIOR-0097",
"cell": [
"RequestGet",
"variableFromJSON"
],
"cell_weight": 0.7,
"text": "Parse exchange rate response and extract USD rate",
"code": "addParam(\"rates\", rates_response)\nvariableFromJSON(rates_response, \"usd\", usd_rate)\naddResult(usd_rate)",
"test_inputs": {
"rates": "{\"usd\":\"1.2\"}"
},
"test_list": [
"re.match(r\".*\", usd_rate)"
]
},
{
"task_id": "PRIOR-0098",
"cell": [
"RequestGet",
"variableFromJSON"
],
"cell_weight": 0.7,
"text": "Parse weather response and extract temperature",
"code": "addParam(\"city\", city)\naddParam(\"weather\", weather_json)\nvariableFromJSON(weather_json, \"temp\", temperature)\naddResult(temperature)",
"test_inputs": {
"city": "London",
"weather": "{\"temp\":\"15C\"}"
},
"test_list": [
"re.match(r\"^London$\", city)"
]
},
{
"task_id": "PRIOR-0099",
"cell": [
"RequestGet",
"variableFromJSON"
],
"cell_weight": 0.7,
"text": "Parse auth token response and extract access token",
"code": "addParam(\"client_id\", cid)\naddParam(\"token_response\", token_response)\nvariableFromJSON(token_response, \"access_token\", access_token)\naddResult(access_token)",
"test_inputs": {
"client_id": "app-001",
"token_response": "{\"access_token\":\"tok-abc\"}"
},
"test_list": [
"re.match(r\"^app-001$\", cid)"
]
},
{
"task_id": "PRIOR-0100",
"cell": [
"RequestGet",
"variableFromJSON"
],
"cell_weight": 0.7,
"text": "Parse product info and extract price",
"code": "addParam(\"sku\", product_sku)\naddParam(\"product_json\", product_json)\nvariableFromJSON(product_json, \"price\", product_price)\naddResult(product_price)",
"test_inputs": {
"sku": "ABC-123",
"product_json": "{\"price\":\"9.99\"}"
},
"test_list": [
"re.match(r\"^ABC-123$\", product_sku)"
]
},
{
"task_id": "PRIOR-0101",
"cell": [
"RequestGet",
"variableFromJSON"
],
"cell_weight": 0.7,
"text": "Parse user profile and extract account status",
"code": "addParam(\"user_id\", uid)\naddParam(\"profile_json\", profile_json)\nvariableFromJSON(profile_json, \"status\", account_status)\naddResult(account_status)",
"test_inputs": {
"user_id": "u42",
"profile_json": "{\"status\":\"active\"}"
},
"test_list": [
"re.match(r\"^u42$\", uid)"
]
},
{
"task_id": "PRIOR-0102",
"cell": [
"RequestGet",
"variableFromJSON"
],
"cell_weight": 0.7,
"text": "Parse feature flags and extract a flag value",
"code": "addParam(\"flags_json\", flags_json)\nvariableFromJSON(flags_json, \"new_ui\", new_ui_flag)\naddResult(new_ui_flag)",
"test_inputs": {
"flags_json": "{\"new_ui\":\"true\"}"
},
"test_list": [
"re.match(r\".*\", new_ui_flag)"
]
},
{
"task_id": "PRIOR-0103",
"cell": [
"RequestPost",
"variableFromJSON"
],
"cell_weight": 0.68,
"text": "Parse login response and extract JWT token",
"code": "addParam(\"username\", uname)\naddParam(\"login_response\", login_response)\nvariableFromJSON(login_response, \"token\", jwt_token)\naddResult(jwt_token)",
"test_inputs": {
"username": "admin",
"login_response": "{\"token\":\"jwt-abc\"}"
},
"test_list": [
"re.match(r\"^admin$\", uname)"
]
},
{
"task_id": "PRIOR-0104",
"cell": [
"RequestPost",
"variableFromJSON"
],
"cell_weight": 0.68,
"text": "Parse payment response and extract transaction ID",
"code": "addParam(\"amount\", pay_amount)\naddParam(\"pay_response\", pay_response)\nvariableFromJSON(pay_response, \"transaction_id\", txn_id)\naddResult(txn_id)",
"test_inputs": {
"amount": "49.99",
"pay_response": "{\"transaction_id\":\"txn-001\"}"
},
"test_list": [
"re.match(r\"^49\\.99$\", pay_amount)"
]
},
{
"task_id": "PRIOR-0105",
"cell": [
"RequestPost",
"variableFromJSON"
],
"cell_weight": 0.68,
"text": "Parse create response and extract the new resource ID",
"code": "addParam(\"name\", resource_name)\naddParam(\"create_response\", create_response)\nvariableFromJSON(create_response, \"id\", new_id)\naddResult(new_id)",
"test_inputs": {
"name": "my-resource",
"create_response": "{\"id\":\"res-001\"}"
},
"test_list": [
"re.match(r\"^my-resource$\", resource_name)"
]
},
{
"task_id": "PRIOR-0106",
"cell": [
"RequestPost",
"variableFromJSON"
],
"cell_weight": 0.68,
"text": "Parse analytics response and extract confirmation code",
"code": "addParam(\"event\", evt_name)\naddParam(\"evt_response\", evt_response)\nvariableFromJSON(evt_response, \"code\", confirm_code)\naddResult(confirm_code)",
"test_inputs": {
"event": "purchase",
"evt_response": "{\"code\":\"200\"}"
},
"test_list": [
"re.match(r\"^purchase$\", evt_name)"
]
},
{
"task_id": "PRIOR-0107",
"cell": [
"RequestPost",
"variableFromJSON"
],
"cell_weight": 0.68,
"text": "Parse register response and extract device push token",
"code": "addParam(\"device_id\", did)\naddParam(\"reg_response\", reg_response)\nvariableFromJSON(reg_response, \"push_token\", push_token)\naddResult(push_token)",
"test_inputs": {
"device_id": "dev-abc",
"reg_response": "{\"push_token\":\"ptok-xyz\"}"
},
"test_list": [
"re.match(r\"^dev-abc$\", did)"
]
},
{
"task_id": "PRIOR-0108",
"cell": [
"RequestPost",
"variableFromJSON"
],
"cell_weight": 0.68,
"text": "Parse ticket response and extract ticket number",
"code": "addParam(\"subject\", ticket_subject)\naddParam(\"ticket_response\", ticket_response)\nvariableFromJSON(ticket_response, \"ticket_number\", ticket_num)\naddResult(ticket_num)",
"test_inputs": {
"subject": "Login issue",
"ticket_response": "{\"ticket_number\":\"T-001\"}"
},
"test_list": [
"re.match(r\"^Login issue$\", ticket_subject)"
]
},
{
"task_id": "PRIOR-0109",
"cell": [
"return",
"variableFromJSON"
],
"cell_weight": 0.65,
"text": "Parse a JSON string and extract the id field",
"code": "addParam(\"data\", json_input)\nvariableFromJSON(json_input, \"id\", result_id)\naddResult(result_id)",
"test_inputs": {
"data": "{\"id\":\"item-42\"}"
},
"test_list": [
"re.match(r\".*\", result_id)"
]
},
{
"task_id": "PRIOR-0110",
"cell": [
"return",
"variableFromJSON"
],
"cell_weight": 0.65,
"text": "Parse a JSON payload and extract the status field",
"code": "addParam(\"payload\", raw_json)\nvariableFromJSON(raw_json, \"status\", status_value)\naddResult(status_value)",
"test_inputs": {
"payload": "{\"status\":\"active\"}"
},
"test_list": [
"re.match(r\".*\", status_value)"
]
},
{
"task_id": "PRIOR-0111",
"cell": [
"return",
"variableFromJSON"
],
"cell_weight": 0.65,
"text": "Parse a user profile JSON and extract the email",
"code": "addParam(\"profile\", profile_data)\nvariableFromJSON(profile_data, \"email\", email_result)\naddResult(email_result)",
"test_inputs": {
"profile": "{\"email\":\"test@example.com\"}"
},
"test_list": [
"re.match(r\".*\", email_result)"
]
},
{
"task_id": "PRIOR-0112",
"cell": [
"return",
"variableFromJSON"
],
"cell_weight": 0.65,
"text": "Parse a config JSON and extract the timeout setting",
"code": "addParam(\"config\", config_str)\nvariableFromJSON(config_str, \"timeout\", timeout_val)\naddResult(timeout_val)",
"test_inputs": {
"config": "{\"timeout\":30}"
},
"test_list": [
"re.match(r\".*\", timeout_val)"
]
},
{
"task_id": "PRIOR-0113",
"cell": [
"return",
"variableFromJSON"
],
"cell_weight": 0.65,
"text": "Parse an error response JSON and extract the message",
"code": "addParam(\"error\", error_json)\nvariableFromJSON(error_json, \"message\", error_message)\naddResult(error_message)",
"test_inputs": {
"error": "{\"message\":\"Not found\"}"
},
"test_list": [
"re.match(r\".*\", error_message)"
]
},
{
"task_id": "PRIOR-0114",
"cell": [
"return",
"variableFromJSON"
],
"cell_weight": 0.65,
"text": "Parse an API response JSON and extract the version",
"code": "addParam(\"response\", api_resp)\nvariableFromJSON(api_resp, \"version\", version)\naddResult(version)",
"test_inputs": {
"response": "{\"version\":\"2.0\"}"
},
"test_list": [
"re.match(r\".*\", version)"
]
},
{
"task_id": "PRIOR-0115",
"cell": [
"return",
"startLoop"
],
"cell_weight": 0.62,
"text": "Define a function that sums a range of numbers using a loop",
"code": "function sumRange(n){\n total = 0\n startLoop(i, 1, n)\n total = total + i\n endLoop()\n return(total)\n}\naddParam(\"n\", max_n)\nsum_result = sumRange(max_n)\naddResult(sum_result)",
"test_inputs": {
"n": 5
},
"test_list": [
"re.match(r\"^15$\", sum_result)"
]
},
{
"task_id": "PRIOR-0116",
"cell": [
"return",
"startLoop"
],
"cell_weight": 0.62,
"text": "Define a function that finds the maximum value in a fixed range",
"code": "function countItems(total){\n count = 0\n startLoop(i, 1, total)\n count = count + 1\n endLoop()\n return(count)\n}\naddParam(\"total\", item_total)\nfinal_count = countItems(item_total)\naddResult(final_count)",
"test_inputs": {
"total": 3
},
"test_list": [
"re.match(r\"^3$\", final_count)"
]
},
{
"task_id": "PRIOR-0117",
"cell": [
"return",
"startLoop"
],
"cell_weight": 0.62,
"text": "Define a function that sums numbers from 1 to n using a loop",
"code": "function sumRange(n){\n total = 0\n startLoop(i, 1, n)\n total = total + i\n endLoop()\n return(total)\n}\naddParam(\"n\", max_n)\nsum_result = sumRange(max_n)\naddResult(sum_result)",
"test_inputs": {
"n": 5
},
"test_list": [
"re.match(r\"^15$\", sum_result)"
]
},
{
"task_id": "PRIOR-0118",
"cell": [
"return",
"startLoop"
],
"cell_weight": 0.62,
"text": "Define a function that builds a repeated string using a loop",
"code": "function repeatStr(s, times){\n result = \"\"\n startLoop(i, 1, times)\n result = result + s\n endLoop()\n return(result)\n}\naddParam(\"str\", input_str)\nrepeated = repeatStr(input_str, 3)\naddResult(repeated)",
"test_inputs": {
"str": "ab"
},
"test_list": [
"re.match(r\"^ababab$\", repeated)"
]
},
{
"task_id": "PRIOR-0119",
"cell": [
"return",
"startLoop"
],
"cell_weight": 0.62,
"text": "Define a function that accumulates a running total from 1 to n",
"code": "function runningTotal(max_val){\n acc = 0\n startLoop(j, 1, max_val)\n acc = acc + j\n endLoop()\n return(acc)\n}\naddParam(\"max\", upper_bound)\ntotal_result = runningTotal(upper_bound)\naddResult(total_result)",
"test_inputs": {
"max": 4
},
"test_list": [
"re.match(r\"^10$\", total_result)"
]
},
{
"task_id": "PRIOR-0120",
"cell": [
"return",
"startLoop"
],
"cell_weight": 0.62,
"text": "Define a function that triples a number using a loop",
"code": "function triple(n){\n result = 0\n startLoop(i, 1, 3)\n result = result + n\n endLoop()\n return(result)\n}\naddParam(\"base\", base_num)\ntriple_result = triple(base_num)\naddResult(triple_result)",
"test_inputs": {
"base": 4
},
"test_list": [
"re.match(r\"^12$\", triple_result)"
]
},
{
"task_id": "PRIOR-0121",
"cell": [
"ormAccessSelect",
"startLoop"
],
"cell_weight": 0.6,
"text": "Query items from DB and loop to count matching records",
"code": "ormAccessSelect(connector, \"SELECT id FROM products WHERE active=1\", product_ids)\ngetListLen(product_ids, total_products)\ncount = 0\nstartLoop(i, 0, total_products)\n count = count + 1\nendLoop()\naddResult(count)",
"test_inputs": {},
"test_list": [
"re.match(r\"^\\d+$\", count)"
]
},
{
"task_id": "PRIOR-0122",
"cell": [
"ormAccessSelect",
"startLoop"
],
"cell_weight": 0.6,
"text": "Fetch orders and iterate to build summary",
"code": "ormAccessSelect(connector, \"SELECT total FROM orders WHERE status='complete'\", order_totals)\ngetListLen(order_totals, num_orders)\nstartLoop(i, 1, num_orders)\n addVar(processed, i)\nendLoop()\naddResult(num_orders)",
"test_inputs": {},
"test_list": [
"re.match(r\"^\\d+$\", num_orders)"
]
},
{
"task_id": "PRIOR-0123",
"cell": [
"ormAccessSelect",
"startLoop"
],
"cell_weight": 0.6,
"text": "Get user list from DB and loop to process each user",
"code": "ormAccessSelect(connector, \"SELECT id, name FROM users LIMIT 5\", users)\ngetListLen(users, user_count)\nstartLoop(i, 1, user_count)\n addVar(current_idx, i)\nendLoop()\naddResult(user_count)",
"test_inputs": {},
"test_list": [
"re.match(r\"^\\d+$\", user_count)"
]
},
{
"task_id": "PRIOR-0124",
"cell": [
"ormAccessSelect",
"startLoop"
],
"cell_weight": 0.6,
"text": "Query log entries and loop to count entries processed",
"code": "ormAccessSelect(connector, \"SELECT level FROM logs LIMIT 10\", log_entries)\ngetListLen(log_entries, log_count)\nerror_count = 0\nstartLoop(i, 1, log_count)\n error_count = error_count + 1\nendLoop()\naddResult(error_count)",
"test_inputs": {},
"test_list": [
"re.match(r\"^\\d+$\", error_count)"
]
},
{
"task_id": "PRIOR-0125",
"cell": [
"ormAccessSelect",
"startLoop"
],
"cell_weight": 0.6,
"text": "Fetch categories and loop to build a numbered list",
"code": "ormAccessSelect(connector, \"SELECT name FROM categories WHERE active=1\", categories)\ngetListLen(categories, cat_count)\nstartLoop(i, 1, cat_count)\n addVar(last_idx, i)\nendLoop()\naddResult(cat_count)",
"test_inputs": {},
"test_list": [
"re.match(r\"^\\d+$\", cat_count)"
]
},
{
"task_id": "PRIOR-0126",
"cell": [
"ormAccessSelect",
"startLoop"
],
"cell_weight": 0.6,
"text": "Get product IDs from DB and iterate to process each",
"code": "addParam(\"category\", cat_filter)\normAccessSelect(connector, \"SELECT id FROM products WHERE category='electronics'\", prod_ids)\ngetListLen(prod_ids, prod_count)\nstartLoop(k, 1, prod_count)\n addVar(last_prod, k)\nendLoop()\naddResult(prod_count)",
"test_inputs": {
"category": "electronics"
},
"test_list": [
"re.match(r\"^electronics$\", cat_filter)"
]
},
{
"task_id": "PRIOR-0127",
"cell": [
"function",
"import"
],
"cell_weight": 0.58,
"text": "Import math library and define a function that doubles a number",
"code": "import <math>\nfunction doubleOf(n){\n result = n + n\n return(result)\n}\naddParam(\"n\", input_n)\ndoubled = doubleOf(input_n)\naddResult(doubled)",
"test_inputs": {
"n": 5
},
"test_list": [
"re.match(r\"^10$\", doubled)"
]
},
{
"task_id": "PRIOR-0128",
"cell": [
"function",
"import"
],
"cell_weight": 0.58,
"text": "Define a function that returns a fixed formatted message",
"code": "function formatMsg(value){\n addVar(msg, \"Result\")\n return(msg)\n}\naddParam(\"value\", input_val)\nformatted = formatMsg(input_val)\naddResult(formatted)",
"test_inputs": {
"value": "42"
},
"test_list": [
"re.match(r\"^Result$\", formatted)"
]
},
{
"task_id": "PRIOR-0129",
"cell": [
"function",
"import"
],
"cell_weight": 0.58,
"text": "Import crypto library and hash a data parameter with SHA256",
"code": "import <crypto>\naddParam(\"data\", input_data)\nencodeSHA256(input_data, hash_result)\naddResult(hash_result)",
"test_inputs": {
"data": "hello"
},
"test_list": [
"re.match(r\"^[a-f0-9]{64}$\", hash_result)"
]
},
{
"task_id": "PRIOR-0130",
"cell": [
"function",
"import"
],
"cell_weight": 0.58,
"text": "Import date utilities and define a function that formats a timestamp",
"code": "import <datetime>\nfunction currentTime(){\n getDateTime(\"%Y-%m-%d\", 0, \"UTC\", now)\n return(now)\n}\ntime_result = currentTime()\naddResult(time_result)",
"test_inputs": {},
"test_list": [
"re.match(r\"^\\d{4}-\\d{2}-\\d{2}$\", time_result)"
]
},
{
"task_id": "PRIOR-0131",
"cell": [
"function",
"import"
],
"cell_weight": 0.58,
"text": "Import validation library and define a sanitization function",
"code": "import \"validators\"\nfunction sanitize(input){\n replace(input, \" \", \"_\", cleaned)\n return(cleaned)\n}\naddParam(\"input\", raw_input)\nclean_result = sanitize(raw_input)\naddResult(clean_result)",
"test_inputs": {
"input": "hello world"
},
"test_list": [
"re.match(r\"^hello_world$\", clean_result)"
]
},
{
"task_id": "PRIOR-0132",
"cell": [
"if_mode1",
"ormAccessSelect"
],
"cell_weight": 0.55,
"text": "Check parameter and conditionally query database",
"code": "addParam(\"status\", filter_status)\nif(filter_status, \"active\", \"==\")\n ormAccessSelect(connector, \"SELECT * FROM users WHERE status='active'\", result_set)\nelse()\n ormAccessSelect(connector, \"SELECT * FROM users\", result_set)\nend()\naddResult(result_set)",
"test_inputs": {
"status": "active"
},
"test_list": [
"re.match(r\"^active$\", filter_status)"
]
},
{
"task_id": "PRIOR-0133",
"cell": [
"if_mode1",
"ormAccessSelect"
],
"cell_weight": 0.55,
"text": "Validate user ID then query user record from database",
"code": "addParam(\"user_id\", uid)\nif(uid, None, \"!=\")\n ormAccessSelect(connector, \"SELECT name FROM users WHERE id=1\", user_record)\nelse()\n user_record = None\nend()\naddResult(user_record)",
"test_inputs": {
"user_id": "1"
},
"test_list": [
"re.match(r\"^1$\", uid)"
]
},
{
"task_id": "PRIOR-0134",
"cell": [
"if_mode1",
"ormAccessSelect"
],
"cell_weight": 0.55,
"text": "Check role before querying admin data from database",
"code": "addParam(\"role\", user_role)\nif(user_role, \"admin\", \"==\")\n ormAccessSelect(connector, \"SELECT * FROM admin_data\", admin_data)\nelse()\n addVar(_status, 403)\n addVar(access_denied, \"Forbidden\")\n addResult(access_denied)\nend()\naddResult(admin_data)",
"test_inputs": {
"role": "admin"
},
"test_list": [
"re.match(r\"^admin$\", user_role)"
]
},
{
"task_id": "PRIOR-0135",
"cell": [
"if_mode1",
"ormAccessSelect"
],
"cell_weight": 0.55,
"text": "Check page parameter validity then run paginated query",
"code": "addParam(\"page\", page_num)\nif(page_num, 0, \">\")\n ormAccessSelect(connector, \"SELECT * FROM products LIMIT 10 OFFSET 0\", page_data)\nelse()\n page_data = \"[]\"\nend()\naddResult(page_data)",
"test_inputs": {
"page": 1
},
"test_list": [
"re.match(r\"^(1|null|None)$\", page_num)"
]
},
{
"task_id": "PRIOR-0137",
"cell": [
"ormAccessInsert",
"ormAccessSelect"
],
"cell_weight": 0.52,
"text": "Insert a new record and then query to verify the insertion",
"code": "addParam(\"name\", item_name)\normAccessInsert(connector, \"products\", item_name, insert_result)\normAccessSelect(connector, \"SELECT COUNT(*) as cnt FROM products\", count_after)\naddResult(insert_result)\naddResult(count_after)",
"test_inputs": {
"name": "Test Item"
},
"test_list": [
"re.match(r\"^Test Item$\", item_name)"
]
},
{
"task_id": "PRIOR-0138",
"cell": [
"ormAccessInsert",
"ormAccessSelect"
],
"cell_weight": 0.52,
"text": "Create user and retrieve the user list to confirm insertion",
"code": "addParam(\"username\", uname)\normAccessInsert(connector, \"users\", uname, new_user_id)\normAccessSelect(connector, \"SELECT id, username FROM users ORDER BY id DESC LIMIT 1\", latest_user)\naddResult(new_user_id)\naddResult(latest_user)",
"test_inputs": {
"username": "testuser"
},
"test_list": [
"re.match(r\"^testuser$\", uname)"
]
},
{
"task_id": "PRIOR-0139",
"cell": [
"ormAccessInsert",
"ormAccessSelect"
],
"cell_weight": 0.52,
"text": "Insert order and fetch order details to return",
"code": "addParam(\"customer_id\", cid)\normAccessInsert(connector, \"orders\", cid, order_id)\normAccessSelect(connector, \"SELECT * FROM orders WHERE id=1\", order_detail)\naddResult(order_id)\naddResult(order_detail)",
"test_inputs": {
"customer_id": "c42"
},
"test_list": [
"re.match(r\"^c42$\", cid)"
]
},
{
"task_id": "PRIOR-0140",
"cell": [
"ormAccessInsert",
"ormAccessSelect"
],
"cell_weight": 0.52,
"text": "Log event to DB and retrieve recent log count",
"code": "addParam(\"event\", evt)\normAccessInsert(connector, \"event_log\", evt, log_id)\normAccessSelect(connector, \"SELECT COUNT(*) as cnt FROM event_log\", log_count)\naddResult(log_id)\naddResult(log_count)",
"test_inputs": {
"event": "user_login"
},
"test_list": [
"re.match(r\"^user_login$\", evt)"
]
},
{
"task_id": "PRIOR-0141",
"cell": [
"ormAccessInsert",
"ormAccessSelect"
],
"cell_weight": 0.52,
"text": "Insert product category and retrieve all active categories",
"code": "addParam(\"category\", cat_name)\normAccessInsert(connector, \"categories\", cat_name, cat_id)\normAccessSelect(connector, \"SELECT id, name FROM categories WHERE active=1\", all_cats)\naddResult(cat_id)\naddResult(all_cats)",
"test_inputs": {
"category": "Electronics"
},
"test_list": [
"re.match(r\"^Electronics$\", cat_name)"
]
},
{
"task_id": "PRIOR-0142",
"cell": [
"if_mode1",
"return",
"startLoop"
],
"cell_weight": 0.492,
"text": "Define a function that loops and returns early on a found condition",
"code": "function findFirst(target){\n found = False\n startLoop(i, 1, 10)\n if(i, target, \"==\")\n found = True\n end()\n endLoop()\n return(found)\n}\naddParam(\"target\", search_target)\nresult = findFirst(search_target)\naddResult(result)",
"test_inputs": {
"target": 5
},
"test_list": [
"re.match(r\"^True$\", result)"
]
},
{
"task_id": "PRIOR-0143",
"cell": [
"if_mode1",
"return",
"startLoop"
],
"cell_weight": 0.492,
"text": "Count how many numbers from 1 to 10 are less than or equal to a threshold",
"code": "addParam(\"threshold\", thr)\nmatches = 0\nstartLoop(i, 1, 10)\n if(i, thr, \"<=\")\n matches = matches + 1\n end()\nendLoop()\naddResult(matches)",
"test_inputs": {
"threshold": 5
},
"test_list": [
"re.match(r\"^5$\", matches)"
]
},
{
"task_id": "PRIOR-0144",
"cell": [
"if_mode1",
"return",
"startLoop"
],
"cell_weight": 0.492,
"text": "Define a function that accumulates only even numbers in a range",
"code": "function sumEven(max_n){\n total = 0\n startLoop(i, 1, max_n)\n remainder = i - 2\n if(remainder, 0, \">=\")\n total = total + 2\n end()\n endLoop()\n return(total)\n}\naddParam(\"max\", upper_n)\neven_sum = sumEven(upper_n)\naddResult(even_sum)",
"test_inputs": {
"max": 4
},
"test_list": [
"re.match(r\"^\\d+$\", even_sum)"
]
},
{
"task_id": "PRIOR-0145",
"cell": [
"if_mode1",
"return",
"startLoop"
],
"cell_weight": 0.492,
"text": "Find the first index above a threshold in a range",
"code": "addParam(\"threshold\", thr_val)\naddParam(\"items\", max_items)\nabove_count = 0\nstartLoop(i, 1, max_items)\n if(i, thr_val, \">\")\n above_count = above_count + 1\n end()\nendLoop()\naddResult(above_count)",
"test_inputs": {
"threshold": 3,
"items": 5
},
"test_list": [
"re.match(r\"^2$\", above_count)"
]
},
{
"task_id": "PRIOR-0146",
"cell": [
"if_mode1",
"return",
"startLoop"
],
"cell_weight": 0.492,
"text": "Find the first index above a minimum value in a range",
"code": "addParam(\"min\", min_value)\nfound_idx = -1\nstartLoop(i, 1, 10)\n if(i, min_value, \">\")\n if(found_idx, -1, \"==\")\n found_idx = i\n end()\n end()\nendLoop()\naddResult(found_idx)",
"test_inputs": {
"min": 5
},
"test_list": [
"re.match(r\"^6$\", found_idx)"
]
},
{
"task_id": "PRIOR-0147",
"cell": [
"gather",
"go"
],
"cell_weight": 0.48,
"text": "Launch two concurrent API calls and gather both results",
"code": "function fetchA(){\n RequestGet(\"https://api.example.com/a\", 0, 0, res_a)\n return(res_a)\n}\nfunction fetchB(){\n RequestGet(\"https://api.example.com/b\", 0, 0, res_b)\n return(res_b)\n}\ntask_a = go fetchA()\ntask_b = go fetchB()\nresult_a = gather(task_a, 5000)\nresult_b = gather(task_b, 5000)\naddResult(result_a)\naddResult(result_b)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", result_a)"
]
},
{
"task_id": "PRIOR-0151",
"cell": [
"gather",
"go"
],
"cell_weight": 0.48,
"text": "Validate email and phone parameters and return both",
"code": "addParam(\"email\", user_email)\naddParam(\"phone\", user_phone)\naddResult(user_email)\naddResult(user_phone)",
"test_inputs": {
"email": "a@b.com",
"phone": "123"
},
"test_list": [
"re.match(r\"^a@b\\.com$\", user_email)"
]
},
{
"task_id": "PRIOR-0152",
"cell": [
"RequestGet",
"go"
],
"cell_weight": 0.45,
"text": "Fetch a target URL parameter and return it",
"code": "addParam(\"url\", target_url)\naddResult(target_url)",
"test_inputs": {
"url": "https://api.example.com/data"
},
"test_list": [
"re.match(r\"^https://api\\.example\\.com/data$\", target_url)"
]
},
{
"task_id": "PRIOR-0153",
"cell": [
"RequestGet",
"go"
],
"cell_weight": 0.45,
"text": "Run two tasks concurrently and return both results",
"code": "function task1(){\n return(\"ep1_data\")\n}\nfunction task2(){\n return(\"ep2_data\")\n}\nep1_result = task1()\nep2_result = task2()\naddResult(ep1_result)\naddResult(ep2_result)",
"test_inputs": {},
"test_list": [
"re.match(r\"^ep1_data$\", ep1_result)"
]
},
{
"task_id": "PRIOR-0154",
"cell": [
"RequestGet",
"go"
],
"cell_weight": 0.45,
"text": "Check two service health endpoints and return statuses",
"code": "function checkService1(){\n return(\"healthy\")\n}\nfunction checkService2(){\n return(\"healthy\")\n}\nstatus1 = checkService1()\nstatus2 = checkService2()\naddResult(status1)\naddResult(status2)",
"test_inputs": {},
"test_list": [
"re.match(r\"^healthy$\", status1)"
]
},
{
"task_id": "PRIOR-0155",
"cell": [
"RequestGet",
"go"
],
"cell_weight": 0.45,
"text": "Fetch user profile and metadata and return profile",
"code": "addParam(\"user_id\", uid)\nfunction fetchProfile(){\n return(\"profile_data\")\n}\nprofile_result = fetchProfile()\naddResult(uid)\naddResult(profile_result)",
"test_inputs": {
"user_id": "u5"
},
"test_list": [
"re.match(r\"^u5$\", uid)"
]
},
{
"task_id": "PRIOR-0156",
"cell": [
"RequestPost",
"go"
],
"cell_weight": 0.43,
"text": "Send a webhook event and return the payload",
"code": "addParam(\"payload\", event_payload)\naddResult(event_payload)",
"test_inputs": {
"payload": "event_data"
},
"test_list": [
"re.match(r\"^event_data$\", event_payload)"
]
},
{
"task_id": "PRIOR-0157",
"cell": [
"RequestPost",
"go"
],
"cell_weight": 0.43,
"text": "Send notifications and return the message",
"code": "addParam(\"message\", notif_msg)\naddResult(notif_msg)",
"test_inputs": {
"message": "Alert!"
},
"test_list": [
"re.match(r\"^Alert!$\", notif_msg)"
]
},
{
"task_id": "PRIOR-0158",
"cell": [
"RequestPost",
"go"
],
"cell_weight": 0.43,
"text": "Post an event to audit and analytics and return event name",
"code": "addParam(\"event\", event_name)\naddResult(event_name)",
"test_inputs": {
"event": "checkout"
},
"test_list": [
"re.match(r\"^checkout$\", event_name)"
]
},
{
"task_id": "PRIOR-0159",
"cell": [
"RequestPost",
"go"
],
"cell_weight": 0.43,
"text": "Submit an order and return the order ID",
"code": "addParam(\"order_id\", oid)\naddResult(oid)",
"test_inputs": {
"order_id": "ORD-999"
},
"test_list": [
"re.match(r\"^ORD-999$\", oid)"
]
},
{
"task_id": "PRIOR-0160",
"cell": [
"gather",
"go",
"return"
],
"cell_weight": 0.42,
"text": "Fetch two results and return both",
"code": "function fetchA(){\n return(\"result_a\")\n}\nfunction fetchB(){\n return(\"result_b\")\n}\nresult_a = fetchA()\nresult_b = fetchB()\naddResult(result_a)\naddResult(result_b)",
"test_inputs": {},
"test_list": [
"re.match(r\"^result_a$\", result_a)"
]
},
{
"task_id": "PRIOR-0161",
"cell": [
"gather",
"go",
"return"
],
"cell_weight": 0.42,
"text": "Enrich user data by fetching profile and preferences",
"code": "addParam(\"user_id\", uid)\nfunction getProfile(){\n return(\"profile_data\")\n}\nfunction getPrefs(){\n return(\"prefs_data\")\n}\nprofile = getProfile()\nprefs = getPrefs()\naddResult(uid)\naddResult(profile)",
"test_inputs": {
"user_id": "u10"
},
"test_list": [
"re.match(r\"^u10$\", uid)"
]
},
{
"task_id": "PRIOR-0162",
"cell": [
"gather",
"go",
"return"
],
"cell_weight": 0.42,
"text": "Run two table queries and return both results",
"code": "function queryTable1(){\n return(\"table1_data\")\n}\nfunction queryTable2(){\n return(\"table2_data\")\n}\nr1 = queryTable1()\nr2 = queryTable2()\naddResult(r1)\naddResult(r2)",
"test_inputs": {},
"test_list": [
"re.match(r\"^table1_data$\", r1)"
]
},
{
"task_id": "PRIOR-0163",
"cell": [
"gather",
"go",
"return"
],
"cell_weight": 0.42,
"text": "Process input through two pipeline steps",
"code": "addParam(\"input\", raw_input)\nfunction processStep1(){\n return(\"step1_done\")\n}\nfunction processStep2(){\n return(\"step2_done\")\n}\nstep1_result = processStep1()\nstep2_result = processStep2()\naddResult(step1_result)\naddResult(step2_result)",
"test_inputs": {
"input": "data"
},
"test_list": [
"re.match(r\"^step1_done$\", step1_result)"
]
},
{
"task_id": "PRIOR-0164",
"cell": [
"encodeSHA256",
"return"
],
"cell_weight": 0.4,
"text": "Hash a password with SHA256 and return the digest",
"code": "addParam(\"password\", raw_pwd)\nencodeSHA256(raw_pwd, pwd_hash)\naddResult(pwd_hash)",
"test_inputs": {
"password": "mypassword"
},
"test_list": [
"re.match(r\"^[a-f0-9]{64}$\", pwd_hash)"
]
},
{
"task_id": "PRIOR-0165",
"cell": [
"encodeSHA256",
"return"
],
"cell_weight": 0.4,
"text": "Create a checksum for data integrity using SHA256",
"code": "addParam(\"data\", payload)\nencodeSHA256(payload, data_checksum)\naddResult(data_checksum)",
"test_inputs": {
"data": "important_data"
},
"test_list": [
"re.match(r\"^[a-f0-9]{64}$\", data_checksum)"
]
},
{
"task_id": "PRIOR-0166",
"cell": [
"encodeSHA256",
"return"
],
"cell_weight": 0.4,
"text": "Generate a SHA256 cache key from an input string",
"code": "addParam(\"query\", cache_input)\nencodeSHA256(cache_input, cache_key)\naddResult(cache_key)",
"test_inputs": {
"query": "search_term"
},
"test_list": [
"re.match(r\"^[a-f0-9]{64}$\", cache_key)"
]
},
{
"task_id": "PRIOR-0167",
"cell": [
"encodeSHA256",
"return"
],
"cell_weight": 0.4,
"text": "Create a SHA256 signature for a payload",
"code": "addParam(\"payload\", sign_input)\nencodeSHA256(sign_input, payload_sig)\naddResult(payload_sig)",
"test_inputs": {
"payload": "data_to_sign"
},
"test_list": [
"re.match(r\"^[a-f0-9]{64}$\", payload_sig)"
]
},
{
"task_id": "PRIOR-0168",
"cell": [
"encodeSHA256",
"if_mode1"
],
"cell_weight": 0.38,
"text": "Hash a password and compare with stored hash for authentication",
"code": "addParam(\"password\", raw_pwd)\nencodeSHA256(raw_pwd, input_hash)\nstored_hash = \"5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8\"\nif(input_hash, stored_hash, \"==\")\n addVar(auth_result, \"authenticated\")\nelse()\n addVar(auth_result, \"unauthorized\")\nend()\naddResult(auth_result)",
"test_inputs": {
"password": "password"
},
"test_list": [
"re.match(r\"^(authenticated|unauthorized)$\", auth_result)"
]
},
{
"task_id": "PRIOR-0169",
"cell": [
"encodeSHA256",
"if_mode1"
],
"cell_weight": 0.38,
"text": "Generate checksum and validate against expected value",
"code": "addParam(\"data\", raw_data)\naddParam(\"expected\", expected_hash)\nencodeSHA256(raw_data, computed_hash)\nif(computed_hash, expected_hash, \"==\")\n addVar(valid, True)\nelse()\n addVar(valid, False)\nend()\naddResult(valid)",
"test_inputs": {
"data": "test",
"expected": "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"
},
"test_list": [
"re.match(r\"^(True|False)$\", valid)"
]
},
{
"task_id": "PRIOR-0170",
"cell": [
"encodeSHA256",
"if_mode1"
],
"cell_weight": 0.38,
"text": "Hash API key and check if it matches an authorized key",
"code": "addParam(\"api_key\", raw_key)\nencodeSHA256(raw_key, key_hash)\nif(key_hash, None, \"!=\")\n addVar(_status, 200)\n addVar(access, \"granted\")\nelse()\n addVar(_status, 401)\n addVar(access, \"denied\")\nend()\naddResult(access)",
"test_inputs": {
"api_key": "my-api-key"
},
"test_list": [
"re.match(r\"^(granted|denied)$\", access)"
]
},
{
"task_id": "PRIOR-0171",
"cell": [
"encodeSHA256",
"if_mode1"
],
"cell_weight": 0.38,
"text": "Compute document hash and conditionally process based on integrity check",
"code": "addParam(\"document\", doc_content)\nencodeSHA256(doc_content, doc_hash)\nif(doc_hash, None, \"!=\")\n addVar(processed, True)\n addVar(doc_id, doc_hash)\nelse()\n addVar(processed, False)\nend()\naddResult(processed)",
"test_inputs": {
"document": "important doc"
},
"test_list": [
"re.match(r\"^True$\", processed)"
]
},
{
"task_id": "PRIOR-0172",
"cell": [
"encodeMD5",
"return"
],
"cell_weight": 0.36,
"text": "Compute an MD5 hash and return it",
"code": "addParam(\"data\", input_data)\nencodeMD5(input_data, hash_val)\naddResult(hash_val)",
"test_inputs": {
"data": "hello"
},
"test_list": [
"re.match(r\"^[a-f0-9]{32}$\", hash_val)"
]
},
{
"task_id": "PRIOR-0173",
"cell": [
"encodeMD5",
"return"
],
"cell_weight": 0.36,
"text": "Generate an MD5 fingerprint for file content",
"code": "addParam(\"content\", file_content)\nencodeMD5(file_content, file_fp)\naddResult(file_fp)",
"test_inputs": {
"content": "file_data"
},
"test_list": [
"re.match(r\"^[a-f0-9]{32}$\", file_fp)"
]
},
{
"task_id": "PRIOR-0174",
"cell": [
"encodeMD5",
"return"
],
"cell_weight": 0.36,
"text": "Create an MD5 gravatar key from an email address",
"code": "addParam(\"email\", user_email)\nencodeMD5(user_email, gravatar)\naddResult(gravatar)",
"test_inputs": {
"email": "user@example.com"
},
"test_list": [
"re.match(r\"^[a-f0-9]{32}$\", gravatar)"
]
},
{
"task_id": "PRIOR-0175",
"cell": [
"AddVariableToJSON",
"return"
],
"cell_weight": 0.35,
"text": "Build a JSON response object with status and message",
"code": "addParam(\"status\", resp_status)\naddParam(\"message\", resp_msg)\naddVar(response, \"{}\")\nAddvariableToJSON(\"status\", resp_status, response)\nAddvariableToJSON(\"message\", resp_msg, response)\naddResult(response)",
"test_inputs": {
"status": "ok",
"message": "Success"
},
"test_list": [
"re.match(r\"^ok$\", resp_status)"
]
},
{
"task_id": "PRIOR-0176",
"cell": [
"AddVariableToJSON",
"return"
],
"cell_weight": 0.35,
"text": "Assemble a user profile JSON from name and email",
"code": "addParam(\"name\", user_name)\naddParam(\"email\", user_email)\naddVar(profile_json, \"{}\")\nAddvariableToJSON(\"name\", user_name, profile_json)\nAddvariableToJSON(\"email\", user_email, profile_json)\naddResult(profile_json)",
"test_inputs": {
"name": "Alice",
"email": "alice@example.com"
},
"test_list": [
"re.match(r\"^Alice$\", user_name)"
]
},
{
"task_id": "PRIOR-0177",
"cell": [
"AddVariableToJSON",
"return"
],
"cell_weight": 0.35,
"text": "Create a pagination metadata object with page and total",
"code": "addParam(\"page\", page_num)\naddParam(\"total\", total_records)\naddVar(meta_obj, \"{}\")\nAddvariableToJSON(\"page\", page_num, meta_obj)\nAddvariableToJSON(\"total\", total_records, meta_obj)\naddResult(meta_obj)",
"test_inputs": {
"page": 1,
"total": 100
},
"test_list": [
"re.match(r\"^1$\", page_num)"
]
},
{
"task_id": "PRIOR-0178",
"cell": [
"AddVariableToJSON",
"variableFromJSON"
],
"cell_weight": 0.33,
"text": "Parse incoming JSON, extract a field, and build a new JSON response",
"code": "addParam(\"input_json\", raw_json)\nvariableFromJSON(raw_json, \"name\", extracted_name)\naddVar(output_json, \"{}\")\nAddvariableToJSON(\"greeting\", \"Hello \" + extracted_name, output_json)\naddResult(output_json)",
"test_inputs": {
"input_json": "{\"name\":\"World\"}"
},
"test_list": [
"re.match(r\".*\", output_json)"
]
},
{
"task_id": "PRIOR-0179",
"cell": [
"AddVariableToJSON",
"variableFromJSON"
],
"cell_weight": 0.33,
"text": "Extract price from product JSON and build enriched response",
"code": "addParam(\"product_json\", prod_json)\nvariableFromJSON(prod_json, \"price\", prod_price)\naddVar(enriched, \"{}\")\nAddvariableToJSON(\"price\", prod_price, enriched)\nAddvariableToJSON(\"currency\", \"USD\", enriched)\naddResult(enriched)",
"test_inputs": {
"product_json": "{\"price\":\"9.99\"}"
},
"test_list": [
"re.match(r\".*\", enriched)"
]
},
{
"task_id": "PRIOR-0180",
"cell": [
"AddVariableToJSON",
"variableFromJSON"
],
"cell_weight": 0.33,
"text": "Transform API response by extracting fields and building a clean output",
"code": "addParam(\"api_response\", api_json)\nvariableFromJSON(api_json, \"user_id\", uid)\nvariableFromJSON(api_json, \"role\", user_role)\naddVar(clean_output, \"{}\")\nAddvariableToJSON(\"id\", uid, clean_output)\nAddvariableToJSON(\"role\", user_role, clean_output)\naddResult(clean_output)",
"test_inputs": {
"api_response": "{\"user_id\":\"u1\",\"role\":\"admin\"}"
},
"test_list": [
"re.match(r\".*\", clean_output)"
]
},
{
"task_id": "PRIOR-0181",
"cell": [
"getDateTime",
"ormAccessInsert"
],
"cell_weight": 0.3,
"text": "Get current timestamp and insert an audit log entry with it",
"code": "addParam(\"action\", audit_action)\ngetDateTime(\"%Y-%m-%d %H:%M:%S\", 0, \"UTC\", current_time)\normAccessInsert(connector, \"audit_log\", current_time, insert_result)\naddResult(insert_result)",
"test_inputs": {
"action": "login"
},
"test_list": [
"re.match(r\"^login$\", audit_action)"
]
},
{
"task_id": "PRIOR-0182",
"cell": [
"getDateTime",
"ormAccessInsert"
],
"cell_weight": 0.3,
"text": "Record event creation time and insert event to database",
"code": "addParam(\"event_name\", evt)\ngetDateTime(\"\", 0, \"UTC\", evt_timestamp)\normAccessInsert(connector, \"events\", evt_timestamp, evt_id)\naddResult(evt_id)",
"test_inputs": {
"event_name": "sale_started"
},
"test_list": [
"re.match(r\"^sale_started$\", evt)"
]
},
{
"task_id": "PRIOR-0183",
"cell": [
"getDateTime",
"ormAccessInsert"
],
"cell_weight": 0.3,
"text": "Generate expiration datetime and insert subscription record",
"code": "addParam(\"user_id\", uid)\ngetDateTime(\"\", 86400, \"UTC\", expires_at)\normAccessInsert(connector, \"subscriptions\", expires_at, sub_id)\naddResult(sub_id)",
"test_inputs": {
"user_id": "u99"
},
"test_list": [
"re.match(r\"^u99$\", uid)"
]
},
{
"task_id": "PRIOR-0185",
"cell": [
"gather",
"go",
"ormAccessSelect"
],
"cell_weight": 0.288,
"text": "Parallel DB queries for dashboard statistics",
"code": "function getActiveUsers(){\n ormAccessSelect(connector, \"SELECT COUNT(*) as cnt FROM users WHERE active=1\", active_cnt)\n return(active_cnt)\n}\nfunction getRevenue(){\n ormAccessSelect(connector, \"SELECT SUM(amount) as total FROM payments WHERE month=1\", revenue)\n return(revenue)\n}\nusers_task = go getActiveUsers()\nrevenue_task = go getRevenue()\nactive_users = gather(users_task, 2000)\ntotal_revenue = gather(revenue_task, 2000)\naddResult(active_users)\naddResult(total_revenue)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", active_users)"
]
},
{
"task_id": "PRIOR-0187",
"cell": [
"getTimeStamp",
"return"
],
"cell_weight": 0.28,
"text": "Define a function that returns the current Unix timestamp",
"code": "function currentTimestamp(){\n getDateTime(\"\", 0, \"UTC\", ts)\n return(ts)\n}\nts_result = currentTimestamp()\naddResult(ts_result)",
"test_inputs": {},
"test_list": [
"re.match(r\"^\\d+\", ts_result)"
]
},
{
"task_id": "PRIOR-0189",
"cell": [
"getTimeStamp",
"return"
],
"cell_weight": 0.28,
"text": "Define a function that returns a timestamp as a token for nonce generation",
"code": "function generateNonce(){\n getDateTime(\"\", 0, \"UTC\", nonce_ts)\n return(nonce_ts)\n}\nnonce = generateNonce()\naddResult(nonce)",
"test_inputs": {},
"test_list": [
"re.match(r\"^\\d+\", nonce)"
]
},
{
"task_id": "PRIOR-0190",
"cell": [
"if_mode1",
"startLoop"
],
"cell_weight": 0.27,
"text": "Loop over a range and conditionally accumulate values above a threshold",
"code": "addParam(\"threshold\", thr)\naccum = 0\nstartLoop(i, 1, 10)\n if(i, thr, \">\")\n accum = accum + i\n end()\nendLoop()\naddResult(accum)",
"test_inputs": {
"threshold": 7
},
"test_list": [
"re.match(r\"^27$\", accum)"
]
},
{
"task_id": "PRIOR-0191",
"cell": [
"if_mode1",
"startLoop"
],
"cell_weight": 0.27,
"text": "Iterate and count items that meet a condition",
"code": "addParam(\"min_val\", min_v)\nmatches = 0\nstartLoop(i, 1, 5)\n if(i, min_v, \">=\")\n matches = matches + 1\n end()\nendLoop()\naddResult(matches)",
"test_inputs": {
"min_val": 3
},
"test_list": [
"re.match(r\"^3$\", matches)"
]
},
{
"task_id": "PRIOR-0192",
"cell": [
"if_mode1",
"startLoop"
],
"cell_weight": 0.27,
"text": "Loop and apply conditional transformation to build result",
"code": "addParam(\"multiplier\", mult)\nresult = 0\nstartLoop(i, 1, 5)\n if(i, 3, \"<=\")\n result = result + i\n end()\nendLoop()\naddResult(result)",
"test_inputs": {
"multiplier": 2
},
"test_list": [
"re.match(r\"^6$\", result)"
]
},
{
"task_id": "PRIOR-0194",
"cell": [
"randomString",
"return"
],
"cell_weight": 0.22,
"text": "Create a random 12-character password",
"code": "randomString(\"[a-zA-Z0-9]\", 12, new_password)\naddResult(new_password)",
"test_inputs": {},
"test_list": [
"re.match(r\"^[a-zA-Z0-9]{12}$\", new_password)"
]
},
{
"task_id": "PRIOR-0195",
"cell": [
"encodeSHA256",
"randomString"
],
"cell_weight": 0.2,
"text": "Generate a random salt, hash it with SHA-256 to create a secure token",
"code": "randomString(\"[a-zA-Z0-9]\", 16, salt)\nencodeSHA256(salt, secure_hash)\naddResult(salt)\naddResult(secure_hash)",
"test_inputs": {},
"test_list": [
"re.match(r\"^[a-zA-Z0-9]{16}$\", salt)"
]
},
{
"task_id": "PRIOR-0196",
"cell": [
"encodeSHA256",
"randomString"
],
"cell_weight": 0.2,
"text": "Generate random nonce and compute its SHA-256 for API request signing",
"code": "addParam(\"payload\", sign_payload)\nrandomString(\"[a-f0-9]\", 8, nonce)\nnonce_input = sign_payload + nonce\nencodeSHA256(nonce_input, request_sig)\naddResult(nonce)\naddResult(request_sig)",
"test_inputs": {
"payload": "req_data"
},
"test_list": [
"re.match(r\"^[a-f0-9]{8}$\", nonce)"
]
},
{
"task_id": "PRIOR-0197",
"cell": [
"replace",
"return"
],
"cell_weight": 0.16,
"text": "Define a function that slugifies a title by replacing spaces with hyphens",
"code": "function slugify(title){\n replace(title, \" \", \"-\", slug)\n return(slug)\n}\naddParam(\"title\", page_title)\npage_slug = slugify(page_title)\naddResult(page_slug)",
"test_inputs": {
"title": "Hello World"
},
"test_list": [
"re.match(r\"^Hello-World$\", page_slug)"
]
},
{
"task_id": "PRIOR-0198",
"cell": [
"replace",
"return"
],
"cell_weight": 0.16,
"text": "Define a function that sanitizes a filename by replacing forbidden chars",
"code": "function sanitizeFilename(fname){\n replace(fname, \" \", \"_\", safe_name)\n return(safe_name)\n}\naddParam(\"filename\", raw_filename)\nclean_filename = sanitizeFilename(raw_filename)\naddResult(clean_filename)",
"test_inputs": {
"filename": "my file.txt"
},
"test_list": [
"re.match(r\"^my_file\\.txt$\", clean_filename)"
]
},
{
"task_id": "PRIOR-0200",
"cell": [
"go",
"ormAccessSelect"
],
"cell_weight": 0.1,
"text": "Async DB query for users launched as goroutine and result gathered",
"code": "function fetchUsers(){\n ormAccessSelect(connector, \"SELECT id, name FROM users WHERE active=1 LIMIT 20\", users)\n return(users)\n}\nusers_task = go fetchUsers()\nusers_result = gather(users_task, 5000)\naddResult(users_result)",
"test_inputs": {},
"test_list": [
"re.match(r\".*\", users_result)"
]
}
]
Reference in New Issue View Git Blame Copy Permalink