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

10462 lines
278 KiB
JSON
Raw Blame History

[
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0001",
"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)"
],
"execution_message": {
"success": true,
"result": {
"error_msg": "Request failed: No error detected",
"respuesta": null
},
"variables": {
"err": "No error detected",
"error_msg": "Request failed: No error detected"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.6880000000000001,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.004,
"success": true
},
{
"command": "exception",
"duration_ms": 0.40499999999999997,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.161,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.061,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.028,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0002",
"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)"
],
"execution_message": {
"success": true,
"result": {
"db_error": "DB error: No error detected",
"rows": null
},
"variables": {
"ormDirect(\"SELECT * FROM users WHERE active": "1\", rows)",
"err": "No error detected",
"_status": 500,
"db_error": "DB error: No error detected"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.16899999999999998,
"success": true
},
{
"command": "assign",
"duration_ms": 0.09899999999999999,
"success": true
},
{
"command": "exception",
"duration_ms": 0.053,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.041,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.1,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0003",
"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)"
],
"execution_message": {
"success": true,
"result": {
"parse_error": "Invalid JSON",
"user_id": "abc123"
},
"variables": {
"payload": "{\"user_id\": \"abc123\"}",
"raw_payload": {
"user_id": "abc123"
},
"user_id": "abc123",
"err": "No error detected",
"_status": 400,
"parse_error": "Invalid JSON"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.228,
"success": true
},
{
"command": "try",
"duration_ms": 0.049,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.054,
"success": true
},
{
"command": "exception",
"duration_ms": 0.036000000000000004,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.038,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 400
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0004",
"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)"
],
"execution_message": {
"success": true,
"result": {
"webhook_error": "Webhook failed",
"webhook_result": {
"error": "HTTPSConnectionPool(host='hook.example.com', port=443): Max retries exceeded with url: /event (Caused by NameResolutionError(\"HTTPSConnection(host='hook.example.com', port=443): Failed to resolve 'hook.example.com' ([Errno -5] No address associated with hostname)\"))"
}
},
"variables": {
"url": "https://hook.example.com/event",
"webhook_url": "https://hook.example.com/event",
"webhook_result": {
"error": "HTTPSConnectionPool(host='hook.example.com', port=443): Max retries exceeded with url: /event (Caused by NameResolutionError(\"HTTPSConnection(host='hook.example.com', port=443): Failed to resolve 'hook.example.com' ([Errno -5] No address associated with hostname)\"))"
},
"err": "No error detected",
"_status": 502,
"webhook_error": "Webhook failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.27999999999999997,
"success": true
},
{
"command": "try",
"duration_ms": 0.06899999999999999,
"success": true
},
{
"command": "RequestPost",
"duration_ms": 51.574000000000005,
"success": true
},
{
"command": "exception",
"duration_ms": 0.159,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.087,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.053,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.093,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.036000000000000004,
"success": true
}
],
"http_status": 502
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0005",
"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)"
],
"execution_message": {
"success": true,
"result": {
"insert_error": "Insert failed: No error detected",
"insert_result": null
},
"variables": {
"name": "Widget Pro",
"product_name": "Widget Pro",
"insert_result": null,
"err": "No error detected",
"_status": 500,
"insert_error": "Insert failed: No error detected"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.306,
"success": true
},
{
"command": "try",
"duration_ms": 0.114,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.118,
"success": true
},
{
"command": "exception",
"duration_ms": 0.045000000000000005,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.04,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.339,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.036000000000000004,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0006",
"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)"
],
"execution_message": {
"success": true,
"result": {
"update_error": "Update failed",
"update_res": null
},
"variables": {
"user_id": "u42",
"uid": "u42",
"ormDirect(\"UPDATE users SET last_login": "NOW WHERE id='%s'\" % uid, update_res)",
"err": "No error detected",
"_status": 200,
"update_error": "Update failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.43,
"success": true
},
{
"command": "try",
"duration_ms": 0.13699999999999998,
"success": true
},
{
"command": "assign",
"duration_ms": 0.116,
"success": true
},
{
"command": "exception",
"duration_ms": 0.05,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.038,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.030000000000000002,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.031,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0007",
"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)"
],
"execution_message": {
"success": true,
"result": {
"config_data": "default"
},
"variables": {
"err": "No error detected",
"config_data": "default"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.14100000000000001,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.003,
"success": true
},
{
"command": "exception",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0008",
"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)"
],
"execution_message": {
"success": true,
"result": {
"auth_error": "Unauthorized",
"auth_result": null
},
"variables": {
"api_key": "sk-test-123",
"RequestGet(\"https://auth.example.com/validate?key": "%s\" % api_key, 0, 0, auth_result)",
"err": "No error detected",
"_status": 401,
"auth_error": "Unauthorized"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.223,
"success": true
},
{
"command": "try",
"duration_ms": 0.073,
"success": true
},
{
"command": "assign",
"duration_ms": 0.11900000000000001,
"success": true
},
{
"command": "exception",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.038,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.033,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.029,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 401
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0009",
"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)"
],
"execution_message": {
"success": true,
"result": {
"result": 25
},
"variables": {
"side": 5,
"s": 5,
"area": 25,
"result": 25
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.19,
"success": true
},
{
"command": "squareArea",
"duration_ms": 0.223,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.048,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0010",
"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)"
],
"execution_message": {
"success": true,
"result": {
"result": "Hello"
},
"variables": {
"name": "Alice",
"user_name": "Alice",
"greeting": "Hello",
"result": "Hello"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.212,
"success": true
},
{
"command": "greetUser",
"duration_ms": 0.17300000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0011",
"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)"
],
"execution_message": {
"success": true,
"result": {
"final": 90
},
"variables": {
"price": 100,
"p": 100,
"discounted": 90,
"final": 90
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.185,
"success": true
},
{
"command": "applyDiscount",
"duration_ms": 0.161,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.055,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0012",
"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)"
],
"execution_message": {
"success": true,
"result": {
"padded_code": "PADDED"
},
"variables": {
"code": "42",
"raw_code": 42,
"padded": "PADDED",
"padded_code": "PADDED"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.175,
"success": true
},
{
"command": "padCode",
"duration_ms": 0.204,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.037,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0013",
"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)"
],
"execution_message": {
"success": true,
"result": {
"temp_result": 30
},
"variables": {
"temp": 20,
"input_temp": 20,
"result": 30,
"temp_result": 30
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.187,
"success": true
},
{
"command": "addOffset",
"duration_ms": 0.14300000000000002,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.041,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0014",
"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)"
],
"execution_message": {
"success": true,
"result": {
"greeting": "Hello!"
},
"variables": {
"name": "Alice",
"user_name": "Alice",
"msg": "Hello!",
"greeting": "Hello!"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.25,
"success": true
},
{
"command": "greet",
"duration_ms": 0.163,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0015",
"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)"
],
"execution_message": {
"success": true,
"result": {
"slug": "page-slug"
},
"variables": {
"title": "my-page",
"page_title": "my-page",
"slug": "page-slug"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.229,
"success": true
},
{
"command": "makeSlug",
"duration_ms": 0.192,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0016",
"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)"
],
"execution_message": {
"success": true,
"result": {
"total_with_tax": 121
},
"variables": {
"amount": 100,
"amt": 100,
"total": 121,
"total_with_tax": 121
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.261,
"success": true
},
{
"command": "addFee",
"duration_ms": 0.212,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.083,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0017",
"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)"
],
"execution_message": {
"success": true,
"result": {
"full_url": "v2"
},
"variables": {
"path": "/users",
"endpoint_path": "/users",
"full_url": "v2"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.214,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.051,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0018",
"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)"
],
"execution_message": {
"success": true,
"result": {
"add_result": 8
},
"variables": {
"a": 5,
"b": 3,
"num_a": 5,
"num_b": 3,
"add_result": 8
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.195,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.052,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0019",
"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)"
],
"execution_message": {
"success": true,
"result": {
"user": "user_row"
},
"variables": {
"user_id": 1,
"ormAccessSelect(connector, \"SELECT name, email FROM users WHERE id": "1\", user_row)",
"user": "user_row"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.217,
"success": true
},
{
"command": "getUser",
"duration_ms": 0.152,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.062,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0020",
"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)"
],
"execution_message": {
"success": true,
"result": {
"price": "0.00"
},
"variables": {
"product": "prod-1",
"pid": "prod-1",
"err": "No error detected",
"price_data": "0.00",
"price": "0.00"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.22699999999999998,
"success": true
},
{
"command": "fetchPrice",
"duration_ms": 0.216,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0021",
"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)"
],
"execution_message": {
"success": true,
"result": {
"hashed_pwd": "fcf730b6d95236ecd3c9fc2d92d7b6b2bb061514961aec041d6c7a7192f592e4"
},
"variables": {
"password": "secret123",
"raw_pwd": "secret123",
"hashed_pwd": "fcf730b6d95236ecd3c9fc2d92d7b6b2bb061514961aec041d6c7a7192f592e4"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.202,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.060000000000000005,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.052,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0022",
"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)"
],
"execution_message": {
"success": true,
"result": {
"log_status": "ok"
},
"variables": {
"event": "login",
"event_name": "login",
"status": "ok",
"log_status": "ok"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.264,
"success": true
},
{
"command": "logEvent",
"duration_ms": 0.431,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.047,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0023",
"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)"
],
"execution_message": {
"success": true,
"result": {
"field_value": "unknown"
},
"variables": {
"data": "{\"id\":\"abc\"}",
"json_data": {
"id": "abc"
},
"field_value": "unknown",
"err": "No error detected"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.23800000000000002,
"success": true
},
{
"command": "try",
"duration_ms": 0.20900000000000002,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.074,
"success": true
},
{
"command": "exception",
"duration_ms": 0.036000000000000004,
"success": true
},
{
"command": "assign",
"duration_ms": 0.114,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0024",
"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)"
],
"execution_message": {
"success": true,
"result": {
"valid_email": "user@example.com"
},
"variables": {
"email": "user@example.com",
"user_email": "user@example.com",
"valid_email": "user@example.com"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.23900000000000002,
"success": true
},
{
"command": "if",
"duration_ms": 0.379,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.066,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0025",
"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)"
],
"execution_message": {
"success": true,
"result": {
"gen_token": "fallback-token"
},
"variables": {
"gen_token": "fallback-token",
"err": "No error detected"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.162,
"success": true
},
{
"command": "randomString",
"duration_ms": 2.3019999999999996,
"success": true
},
{
"command": "exception",
"duration_ms": 0.107,
"success": true
},
{
"command": "assign",
"duration_ms": 0.09899999999999999,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.037,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0026",
"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)"
],
"execution_message": {
"success": false,
"error": "No inspection system is available for object of type <class 'NoneType'>"
},
"passed": false,
"error": "No inspection system is available for object of type <class 'NoneType'>",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0027",
"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)"
],
"execution_message": {
"success": true,
"result": {
"db_error": "Query failed",
"users_list": null
},
"variables": {
"null": [],
"err": "No error detected",
"_status": 500,
"db_error": "Query failed"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.166,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 0.244,
"success": true
},
{
"command": "exception",
"duration_ms": 0.049,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.051,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.046,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034999999999999996,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0028",
"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)"
],
"execution_message": {
"success": true,
"result": {
"not_found": "Product not found",
"product": null
},
"variables": {
"id": "1",
"product_id": 1,
"ormAccessSelect(connector, \"SELECT name FROM products WHERE id": "1\", product)",
"err": "No error detected",
"_status": 404,
"not_found": "Product not found"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.22599999999999998,
"success": true
},
{
"command": "try",
"duration_ms": 0.235,
"success": true
},
{
"command": "assign",
"duration_ms": 0.112,
"success": true
},
{
"command": "exception",
"duration_ms": 0.052,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.058,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.036000000000000004,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.041999999999999996,
"success": true
}
],
"http_status": 404
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0029",
"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)"
],
"execution_message": {
"success": true,
"result": {
"count_result": 0
},
"variables": {
"ormAccessSelect(connector, \"SELECT COUNT(*) as cnt FROM sessions WHERE active": "1\", count_result)",
"err": "No error detected",
"count_result": 0
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.289,
"success": true
},
{
"command": "assign",
"duration_ms": 0.11299999999999999,
"success": true
},
{
"command": "exception",
"duration_ms": 0.06499999999999999,
"success": true
},
{
"command": "assign",
"duration_ms": 0.066,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.036000000000000004,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0030",
"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)"
],
"execution_message": {
"success": true,
"result": {
"orders": "[]"
},
"variables": {
"page": "1",
"page_num": 1,
"null": [],
"err": "No error detected",
"_status": 500,
"orders": "[]"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.19,
"success": true
},
{
"command": "try",
"duration_ms": 0.438,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 0.448,
"success": true
},
{
"command": "exception",
"duration_ms": 0.132,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "assign",
"duration_ms": 0.082,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0031",
"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)"
],
"execution_message": {
"success": true,
"result": {
"search_results": "[]"
},
"variables": {
"keyword": "test",
"search_term": "test",
"null": [],
"err": "No error detected",
"_status": 500,
"search_results": "[]"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 1.452,
"success": true
},
{
"command": "try",
"duration_ms": 0.36000000000000004,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 1.888,
"success": true
},
{
"command": "exception",
"duration_ms": 0.111,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.054,
"success": true
},
{
"command": "assign",
"duration_ms": 0.5720000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.066,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0032",
"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)"
],
"execution_message": {
"success": true,
"result": {
"svc_err": "Service unavailable",
"events": null
},
"variables": {
"null": [],
"err": "No error detected",
"_status": 503,
"svc_err": "Service unavailable"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.145,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 0.219,
"success": true
},
{
"command": "exception",
"duration_ms": 0.051,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.393,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.064,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.054,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.036000000000000004,
"success": true
}
],
"http_status": 503
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0033",
"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)"
],
"execution_message": {
"success": true,
"result": {
"perm_error": "Access denied",
"roles": null
},
"variables": {
"user_id": "1",
"uid": 1,
"ormAccessSelect(connector, \"SELECT role FROM user_roles WHERE user_id": "1\", roles)",
"err": "No error detected",
"_status": 403,
"perm_error": "Access denied"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.182,
"success": true
},
{
"command": "try",
"duration_ms": 0.054,
"success": true
},
{
"command": "assign",
"duration_ms": 0.15100000000000002,
"success": true
},
{
"command": "exception",
"duration_ms": 0.08,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034999999999999996,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.028,
"success": true
}
],
"http_status": 403
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0034",
"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)"
],
"execution_message": {
"success": true,
"result": {
"available": "True"
},
"variables": {
"username": "testuser",
"uname": "testuser",
"ormAccessSelect(connector, \"SELECT id FROM users WHERE username": "'testuser'\", exists_check)",
"err": "No error detected",
"exists_check": null,
"available": "True"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.254,
"success": true
},
{
"command": "try",
"duration_ms": 0.061,
"success": true
},
{
"command": "assign",
"duration_ms": 0.10900000000000001,
"success": true
},
{
"command": "exception",
"duration_ms": 0.060000000000000005,
"success": true
},
{
"command": "assign",
"duration_ms": 0.062,
"success": true
},
{
"command": "if",
"duration_ms": 2.033,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.076,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0035",
"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)"
],
"execution_message": {
"success": true,
"result": {
"err_msg": "Inventory query failed",
"inventory": null
},
"variables": {
"ormAccessSelect(connector, \"SELECT sku, qty FROM inventory WHERE active": "1\", inventory)",
"err": "No error detected",
"_status": 500,
"err_msg": "Inventory query failed"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.122,
"success": true
},
{
"command": "assign",
"duration_ms": 0.06999999999999999,
"success": true
},
{
"command": "exception",
"duration_ms": 0.044,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034999999999999996,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0036",
"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)"
],
"execution_message": {
"success": true,
"result": {
"query_err": "Orders fetch failed",
"orders": null
},
"variables": {
"customer_id": "1",
"cid": 1,
"ormAccessSelect(connector, \"SELECT * FROM orders WHERE customer_id": "1\", orders)",
"err": "No error detected",
"_status": 500,
"query_err": "Orders fetch failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.211,
"success": true
},
{
"command": "try",
"duration_ms": 0.073,
"success": true
},
{
"command": "assign",
"duration_ms": 0.118,
"success": true
},
{
"command": "exception",
"duration_ms": 0.05,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.05,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0037",
"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)"
],
"execution_message": {
"success": true,
"result": {
"catalog_err": "Catalog unavailable",
"catalog": null
},
"variables": {
"ormAccessSelect(connector, \"SELECT id, name, price FROM products WHERE published": "1\", catalog)",
"err": "No error detected",
"_status": 503,
"catalog_err": "Catalog unavailable"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.166,
"success": true
},
{
"command": "assign",
"duration_ms": 0.08600000000000001,
"success": true
},
{
"command": "exception",
"duration_ms": 0.068,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.352,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.09000000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.06999999999999999,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.028,
"success": true
}
],
"http_status": 503
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0038",
"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)"
],
"execution_message": {
"success": true,
"result": {
"metric_err": "Metrics unavailable",
"metrics": null
},
"variables": {
"null": [],
"err": "No error detected",
"_status": 500,
"metric_err": "Metrics unavailable"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.153,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 0.11900000000000001,
"success": true
},
{
"command": "exception",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.045000000000000005,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.047,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.038,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.030000000000000002,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0039",
"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)"
],
"execution_message": {
"success": true,
"result": {
"report_err": "Report not found or query error",
"report": null
},
"variables": {
"report_id": "1",
"rid": 1,
"ormAccessSelect(connector, \"SELECT * FROM reports WHERE id": "1 AND status='ready'\", report)",
"err": "No error detected",
"_status": 404,
"report_err": "Report not found or query error"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.222,
"success": true
},
{
"command": "try",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "assign",
"duration_ms": 0.136,
"success": true
},
{
"command": "exception",
"duration_ms": 0.044,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.033,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.439,
"success": true
}
],
"http_status": 404
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0040",
"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)"
],
"execution_message": {
"success": true,
"result": {
"analytics": "[]"
},
"variables": {
"null": [],
"err": "No error detected",
"analytics": "[]",
"degraded": "True"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.163,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 0.15100000000000002,
"success": true
},
{
"command": "exception",
"duration_ms": 0.048,
"success": true
},
{
"command": "assign",
"duration_ms": 0.51,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.162,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.04,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0041",
"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)"
],
"execution_message": {
"success": true,
"result": {
"search_err": "User search failed: No error detected",
"user_result": null
},
"variables": {
"email": "test@example.com",
"search_email": "test@example.com",
"ormAccessSelect(connector, \"SELECT id, name FROM users WHERE email": "'test@example.com'\", user_result)",
"err": "No error detected",
"_status": 500,
"search_err": "User search failed: No error detected"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.264,
"success": true
},
{
"command": "try",
"duration_ms": 0.067,
"success": true
},
{
"command": "assign",
"duration_ms": 0.115,
"success": true
},
{
"command": "exception",
"duration_ms": 0.058,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.048,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.524,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.07100000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.036000000000000004,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0042",
"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)"
],
"execution_message": {
"success": true,
"result": {
"settings": "{}"
},
"variables": {
"ormAccessSelect(connector, \"SELECT key, value FROM settings WHERE active": "1\", settings)",
"err": "No error detected",
"settings": "{}",
"using_defaults": "True"
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.185,
"success": true
},
{
"command": "assign",
"duration_ms": 0.096,
"success": true
},
{
"command": "exception",
"duration_ms": 0.059,
"success": true
},
{
"command": "assign",
"duration_ms": 0.5630000000000001,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.088,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034999999999999996,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0043",
"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)"
],
"execution_message": {
"success": true,
"result": {
"weather_err": "Weather service unavailable",
"weather": null
},
"variables": {
"city": "Madrid",
"city_name": "Madrid",
"RequestGet(\"https://api.weather.example.com/current?city": "%s\" % city_name, 0, 0, weather)",
"err": "No error detected",
"_status": 503,
"weather_err": "Weather service unavailable"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.208,
"success": true
},
{
"command": "try",
"duration_ms": 0.053,
"success": true
},
{
"command": "assign",
"duration_ms": 0.095,
"success": true
},
{
"command": "exception",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.038,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 503
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0044",
"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)"
],
"execution_message": {
"success": true,
"result": {
"rate": "1.0"
},
"variables": {
"currency": "EUR",
"currency_code": "EUR",
"RequestGet(\"https://api.exchange.example.com/rate?from": "USD&to=%s\" % currency_code, 0, 0, rate)",
"err": "No error detected",
"rate": "1.0"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.26899999999999996,
"success": true
},
{
"command": "try",
"duration_ms": 0.052,
"success": true
},
{
"command": "assign",
"duration_ms": 0.565,
"success": true
},
{
"command": "exception",
"duration_ms": 0.121,
"success": true
},
{
"command": "assign",
"duration_ms": 0.077,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.038,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0045",
"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)"
],
"execution_message": {
"success": true,
"result": {
"auth_err": "Invalid token",
"profile": null
},
"variables": {
"token": "tok-abc",
"auth_token": "tok-abc",
"err": "No error detected",
"_status": 401,
"auth_err": "Invalid token"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.31,
"success": true
},
{
"command": "try",
"duration_ms": 0.23900000000000002,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.003,
"success": true
},
{
"command": "exception",
"duration_ms": 0.056,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.04,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.036000000000000004,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.049,
"success": true
}
],
"http_status": 401
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0046",
"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)"
],
"execution_message": {
"success": true,
"result": {
"product_detail": null
},
"variables": {
"sku": "SKU-001",
"product_sku": "SKU-001",
"err": "No error detected",
"product_detail": null,
"_status": 502
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.23800000000000002,
"success": true
},
{
"command": "try",
"duration_ms": 0.063,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.003,
"success": true
},
{
"command": "exception",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "assign",
"duration_ms": 0.12000000000000001,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 502
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0047",
"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)"
],
"execution_message": {
"success": true,
"result": {
"health_check": "unhealthy"
},
"variables": {
"err": "No error detected",
"health_check": "unhealthy",
"_status": 503
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.159,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.004,
"success": true
},
{
"command": "exception",
"duration_ms": 0.092,
"success": true
},
{
"command": "assign",
"duration_ms": 0.124,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.063,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.039,
"success": true
}
],
"http_status": 503
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0048",
"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)"
],
"execution_message": {
"success": true,
"result": {
"geo_data": "unknown"
},
"variables": {
"ip": "8.8.8.8",
"ip_address": "8.8.8.8",
"RequestGet(\"https://geo.example.com/lookup?ip": "%s\" % ip_address, 0, 0, geo_data)",
"err": "No error detected",
"geo_data": "unknown"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.331,
"success": true
},
{
"command": "try",
"duration_ms": 0.154,
"success": true
},
{
"command": "assign",
"duration_ms": 0.221,
"success": true
},
{
"command": "exception",
"duration_ms": 0.07200000000000001,
"success": true
},
{
"command": "assign",
"duration_ms": 0.067,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.043000000000000003,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0049",
"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)"
],
"execution_message": {
"success": true,
"result": {
"news_feed": "[]"
},
"variables": {
"err": "No error detected",
"news_feed": "[]",
"_status": 503
},
"assertion_result": true,
"logs": [
{
"command": "try",
"duration_ms": 0.13999999999999999,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.003,
"success": true
},
{
"command": "exception",
"duration_ms": 0.05,
"success": true
},
{
"command": "assign",
"duration_ms": 0.10900000000000001,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.041,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 503
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0050",
"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)"
],
"execution_message": {
"success": true,
"result": {
"quote": null
},
"variables": {
"weight": "5",
"package_weight": 5,
"RequestGet(\"https://logistics.example.com/quote?weight": "%s\" % package_weight, 0, 0, quote)",
"err": "No error detected",
"quote": null,
"_status": 502
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.17200000000000001,
"success": true
},
{
"command": "try",
"duration_ms": 0.037,
"success": true
},
{
"command": "assign",
"duration_ms": 0.118,
"success": true
},
{
"command": "exception",
"duration_ms": 0.043000000000000003,
"success": true
},
{
"command": "assign",
"duration_ms": 0.055,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.04,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
}
],
"http_status": 502
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0051",
"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)"
],
"execution_message": {
"success": true,
"result": {
"fulfill_err": "Fulfillment failed",
"fulfill_result": null
},
"variables": {
"order_id": "ORD-123",
"oid": "ORD-123",
"err": "No error detected",
"_status": 502,
"fulfill_err": "Fulfillment failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.216,
"success": true
},
{
"command": "try",
"duration_ms": 0.044,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.002,
"success": true
},
{
"command": "exception",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034999999999999996,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 502
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0052",
"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)"
],
"execution_message": {
"success": true,
"result": {
"push_result": "failed"
},
"variables": {
"user_id": "u99",
"uid": "u99",
"err": "No error detected",
"push_result": "failed",
"_status": 503
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.212,
"success": true
},
{
"command": "try",
"duration_ms": 0.27599999999999997,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.004,
"success": true
},
{
"command": "exception",
"duration_ms": 0.060000000000000005,
"success": true
},
{
"command": "assign",
"duration_ms": 0.11699999999999999,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.051,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.044,
"success": true
}
],
"http_status": 503
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0053",
"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)"
],
"execution_message": {
"success": true,
"result": {
"payment_err": "Payment processing failed",
"payment_result": null
},
"variables": {
"amount": "99.99",
"payment_amount": 99.99,
"err": "No error detected",
"_status": 402,
"payment_err": "Payment processing failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.18000000000000002,
"success": true
},
{
"command": "try",
"duration_ms": 0.039,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.004,
"success": true
},
{
"command": "exception",
"duration_ms": 0.051,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.083,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.038,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 402
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0054",
"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)"
],
"execution_message": {
"success": true,
"result": {
"sub_result": null
},
"variables": {
"callback_url": "https://myapp.com/hook",
"webhook_url": "https://myapp.com/hook",
"err": "No error detected",
"sub_result": null,
"_status": 400
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.285,
"success": true
},
{
"command": "try",
"duration_ms": 0.073,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.003,
"success": true
},
{
"command": "exception",
"duration_ms": 0.052,
"success": true
},
{
"command": "assign",
"duration_ms": 0.156,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.061,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 400
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0055",
"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)"
],
"execution_message": {
"success": true,
"result": {
"track_result": "ignored"
},
"variables": {
"event_name": "page_view",
"evt": "page_view",
"err": "No error detected",
"track_result": "ignored"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.259,
"success": true
},
{
"command": "try",
"duration_ms": 0.079,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.004,
"success": true
},
{
"command": "exception",
"duration_ms": 0.044,
"success": true
},
{
"command": "assign",
"duration_ms": 0.107,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.38,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0056",
"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)"
],
"execution_message": {
"success": true,
"result": {
"mail_err": "Email delivery failed",
"mail_result": null
},
"variables": {
"to": "user@example.com",
"recipient_email": "user@example.com",
"err": "No error detected",
"_status": 503,
"mail_err": "Email delivery failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.266,
"success": true
},
{
"command": "try",
"duration_ms": 0.053,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.003,
"success": true
},
{
"command": "exception",
"duration_ms": 0.041,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.05,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.051,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 503
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0057",
"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)"
],
"execution_message": {
"success": true,
"result": {
"create_err": "User creation failed",
"create_result": null
},
"variables": {
"username": "newuser",
"new_username": "newuser",
"err": "No error detected",
"_status": 201,
"create_err": "User creation failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.228,
"success": true
},
{
"command": "try",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.002,
"success": true
},
{
"command": "exception",
"duration_ms": 0.40900000000000003,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.048,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.036000000000000004,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.031,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 201
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0058",
"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)"
],
"execution_message": {
"success": true,
"result": {
"crm_err": "CRM submission failed",
"crm_result": null
},
"variables": {
"contact_name": "Jane Smith",
"contact": "Jane Smith",
"err": "No error detected",
"_status": 422,
"crm_err": "CRM submission failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.24600000000000002,
"success": true
},
{
"command": "try",
"duration_ms": 0.054,
"success": true
},
{
"command": "connector_call",
"duration_ms": 0.003,
"success": true
},
{
"command": "exception",
"duration_ms": 0.04,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.044,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.102,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 422
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0059",
"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)"
],
"execution_message": {
"success": true,
"result": {
"final_grade": "A"
},
"variables": {
"score": "95",
"student_score": 95,
"grade": "A",
"final_grade": "A"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.207,
"success": true
},
{
"command": "getGrade",
"duration_ms": 0.91,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.078,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0060",
"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)"
],
"execution_message": {
"success": true,
"result": {
"permission": "full"
},
"variables": {
"role": "admin",
"user_role": "admin",
"permission": "full"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.21800000000000003,
"success": true
},
{
"command": "if",
"duration_ms": 0.382,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.054,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0061",
"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)"
],
"execution_message": {
"success": true,
"result": {
"in_stock": true
},
"variables": {
"quantity": 5,
"stock_qty": 5,
"in_stock": true
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.165,
"success": true
},
{
"command": "if",
"duration_ms": 0.364,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.054,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0062",
"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)"
],
"execution_message": {
"success": true,
"result": {
"shipping": "free"
},
"variables": {
"total": 150,
"order_total": 150,
"shipping": "free"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.163,
"success": true
},
{
"command": "if",
"duration_ms": 0.333,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.053,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0063",
"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)"
],
"execution_message": {
"success": true,
"result": {
"age_cat": "adult"
},
"variables": {
"age": 25,
"user_age": 25,
"age_cat": "adult"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.283,
"success": true
},
{
"command": "if",
"duration_ms": 0.767,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.115,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0064",
"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)"
],
"execution_message": {
"success": true,
"result": {
"leap_result": true
},
"variables": {
"year": 4,
"input_year": 4,
"leap_result": true
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.235,
"success": true
},
{
"command": "if",
"duration_ms": 0.877,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.096,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0065",
"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)"
],
"execution_message": {
"success": true,
"result": {
"status_label": "OK"
},
"variables": {
"code": 200,
"http_code": 200,
"status_label": "OK"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.213,
"success": true
},
{
"command": "if",
"duration_ms": 0.851,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.081,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0066",
"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)"
],
"execution_message": {
"success": true,
"result": {
"valid": true
},
"variables": {
"value": 10,
"input_val": 10,
"valid": true
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.183,
"success": true
},
{
"command": "if",
"duration_ms": 0.395,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.057,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0067",
"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)"
],
"execution_message": {
"success": true,
"result": {
"temp_label": "hot"
},
"variables": {
"temp": 35,
"temperature": 35,
"temp_label": "hot"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.18100000000000002,
"success": true
},
{
"command": "if",
"duration_ms": 0.606,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.054,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0068",
"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)"
],
"execution_message": {
"success": true,
"result": {
"outcome": "pass"
},
"variables": {
"score": 75,
"test_score": 75,
"outcome": "pass"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.18000000000000002,
"success": true
},
{
"command": "if",
"duration_ms": 0.378,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.056,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0069",
"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)"
],
"execution_message": {
"success": true,
"result": {
"pricing": "bulk"
},
"variables": {
"qty": 150,
"order_qty": 150,
"pricing": "bulk"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.675,
"success": true
},
{
"command": "if",
"duration_ms": 1.312,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.093,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0070",
"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)"
],
"execution_message": {
"success": true,
"result": {
"pin_status": "valid"
},
"variables": {
"pin": "1234",
"user_pin": 1234,
"pin_status": "valid"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.294,
"success": true
},
{
"command": "if",
"duration_ms": 0.896,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.082,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0071",
"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)"
],
"execution_message": {
"success": true,
"result": {
"priority": "high"
},
"variables": {
"urgency": 9,
"urgency_score": 9,
"priority": "high"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.205,
"success": true
},
{
"command": "if",
"duration_ms": 1.2080000000000002,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.06999999999999999,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0072",
"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)"
],
"execution_message": {
"success": true,
"result": {
"sub": "active"
},
"variables": {
"days": 15,
"days_remaining": 15,
"sub": "active"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.174,
"success": true
},
{
"command": "if",
"duration_ms": 0.33799999999999997,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.04,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0073",
"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)"
],
"execution_message": {
"success": true,
"result": {
"weight_cat": "light"
},
"variables": {
"weight": 5,
"item_weight": 5,
"weight_cat": "light"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.176,
"success": true
},
{
"command": "if",
"duration_ms": 0.348,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.043000000000000003,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0074",
"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)"
],
"execution_message": {
"success": true,
"result": {
"pwd_level": "strong"
},
"variables": {
"length": 15,
"pwd_length": 15,
"pwd_level": "strong"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.22699999999999998,
"success": true
},
{
"command": "if",
"duration_ms": 1.5939999999999999,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.066,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0075",
"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)"
],
"execution_message": {
"success": true,
"result": {
"user_data": "user_row"
},
"variables": {
"user_id": 1,
"ormAccessSelect(connector, \"SELECT name, email FROM users WHERE id": "1\", user_row)",
"user_data": "user_row"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.24000000000000002,
"success": true
},
{
"command": "getUser",
"duration_ms": 0.148,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.05,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0076",
"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)"
],
"execution_message": {
"success": true,
"result": {
"products": "catalog"
},
"variables": {
"ormAccessSelect(connector, \"SELECT id, name, price FROM products WHERE active": "1\", catalog)",
"products": "catalog"
},
"assertion_result": true,
"logs": [
{
"command": "getCatalog",
"duration_ms": 0.153,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.129,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0077",
"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)"
],
"execution_message": {
"success": true,
"result": {
"pending_count": "count_row"
},
"variables": {
"ormAccessSelect(connector, \"SELECT COUNT(*) as cnt FROM orders WHERE status": "'pending'\", count_row)",
"pending_count": "count_row"
},
"assertion_result": true,
"logs": [
{
"command": "getPendingCount",
"duration_ms": 0.164,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.11299999999999999,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0078",
"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)"
],
"execution_message": {
"success": true,
"result": {
"user_roles": "roles"
},
"variables": {
"user_id": "1",
"uid": 1,
"ormAccessSelect(connector, \"SELECT role FROM user_roles WHERE user_id": "1\", roles)",
"user_roles": "roles"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 1.358,
"success": true
},
{
"command": "getUserRoles",
"duration_ms": 0.232,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.077,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0079",
"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)"
],
"execution_message": {
"success": true,
"result": {
"audit": "audit_entries"
},
"variables": {
"limit": "10",
"log_limit": 10,
"null": [],
"audit": "audit_entries"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.187,
"success": true
},
{
"command": "getAuditLog",
"duration_ms": 0.24600000000000002,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.039,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0080",
"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)"
],
"execution_message": {
"success": true,
"result": {
"app_config": "config_rows"
},
"variables": {
"ormAccessSelect(connector, \"SELECT setting_key, setting_value FROM config WHERE active": "1\", config_rows)",
"app_config": "config_rows"
},
"assertion_result": true,
"logs": [
{
"command": "getConfig",
"duration_ms": 0.221,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.118,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0081",
"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)"
],
"execution_message": {
"success": true,
"result": {
"category_items": "results"
},
"variables": {
"category": "electronics",
"cat_name": "electronics",
"ormAccessSelect(connector, \"SELECT id, name FROM products WHERE category": "'electronics'\", results)",
"category_items": "results"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.202,
"success": true
},
{
"command": "getByCategory",
"duration_ms": 0.17300000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.05,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0082",
"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)"
],
"execution_message": {
"success": true,
"result": {
"dup_error": "Email already exists",
"insert_result": null
},
"variables": {
"email": "new@example.com",
"user_email": "new@example.com",
"insert_result": null,
"err": "No error detected",
"_status": 409,
"dup_error": "Email already exists"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.725,
"success": true
},
{
"command": "try",
"duration_ms": 0.248,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.465,
"success": true
},
{
"command": "exception",
"duration_ms": 0.061,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.045000000000000005,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.037,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.077,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034999999999999996,
"success": true
}
],
"http_status": 409
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0083",
"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)"
],
"execution_message": {
"success": true,
"result": {
"order_err": "Order creation failed",
"order_id": null
},
"variables": {
"order_data": "{\"total\":99.99}",
"order_json": {
"total": 99.99
},
"order_id": null,
"err": "No error detected",
"_status": 422,
"order_err": "Order creation failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.19699999999999998,
"success": true
},
{
"command": "try",
"duration_ms": 0.039,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.107,
"success": true
},
{
"command": "exception",
"duration_ms": 0.038,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.052,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 422
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0084",
"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)"
],
"execution_message": {
"success": true,
"result": {
"prod_err": "Product insert failed",
"prod_result": null
},
"variables": {
"product_name": "New Product",
"pname": "New Product",
"prod_result": null,
"err": "No error detected",
"_status": 201,
"prod_err": "Product insert failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.201,
"success": true
},
{
"command": "try",
"duration_ms": 0.039,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.122,
"success": true
},
{
"command": "exception",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.04,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.031,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 201
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0085",
"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)"
],
"execution_message": {
"success": true,
"result": {
"audit_result": "logged_failed"
},
"variables": {
"action": "login",
"audit_action": "login",
"audit_result": "logged_failed",
"err": "No error detected"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.208,
"success": true
},
{
"command": "try",
"duration_ms": 0.092,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.11,
"success": true
},
{
"command": "exception",
"duration_ms": 0.038,
"success": true
},
{
"command": "assign",
"duration_ms": 0.104,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0086",
"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)"
],
"execution_message": {
"success": true,
"result": {
"sess_err": "Session creation failed",
"sess_result": null
},
"variables": {
"session_token": "tok-xyz",
"sess_tok": "tok-xyz",
"sess_result": null,
"err": "No error detected",
"_status": 500,
"sess_err": "Session creation failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.215,
"success": true
},
{
"command": "try",
"duration_ms": 0.04,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.106,
"success": true
},
{
"command": "exception",
"duration_ms": 0.038,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034999999999999996,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.34400000000000003,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.054,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0087",
"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)"
],
"execution_message": {
"success": true,
"result": {
"fb_err": "Feedback save failed",
"fb_result": null
},
"variables": {
"message": "Great service!",
"feedback_msg": "Great service!",
"fb_result": null,
"err": "No error detected",
"_status": 500,
"fb_err": "Feedback save failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.228,
"success": true
},
{
"command": "try",
"duration_ms": 0.044,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.11,
"success": true
},
{
"command": "exception",
"duration_ms": 0.038,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.04,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0088",
"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)"
],
"execution_message": {
"success": true,
"result": {
"notif_result": null
},
"variables": {
"notif_type": "email",
"ntype": "email",
"notif_result": null,
"err": "No error detected"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.221,
"success": true
},
{
"command": "try",
"duration_ms": 0.063,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.106,
"success": true
},
{
"command": "exception",
"duration_ms": 0.037,
"success": true
},
{
"command": "assign",
"duration_ms": 0.103,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0089",
"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)"
],
"execution_message": {
"success": true,
"result": {
"upd_err": "User not found",
"update_result": null
},
"variables": {
"user_id": "1",
"new_email": "updated@example.com",
"uid": 1,
"email": "updated@example.com",
"ormAccessUpdate(connector, \"UPDATE users SET email": "'%s' WHERE id=1\" % email, update_result)",
"err": "No error detected",
"_status": 200,
"upd_err": "User not found"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.191,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.088,
"success": true
},
{
"command": "try",
"duration_ms": 0.038,
"success": true
},
{
"command": "assign",
"duration_ms": 0.104,
"success": true
},
{
"command": "exception",
"duration_ms": 0.038,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.08,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.029,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0090",
"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)"
],
"execution_message": {
"success": true,
"result": {
"deact_err": "Deactivation failed",
"deact_result": null
},
"variables": {
"product_id": "1",
"pid": 1,
"ormAccessUpdate(connector, \"UPDATE products SET active": "0 WHERE id=1\", deact_result)",
"err": "No error detected",
"_status": 500,
"deact_err": "Deactivation failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.159,
"success": true
},
{
"command": "try",
"duration_ms": 0.039,
"success": true
},
{
"command": "assign",
"duration_ms": 0.102,
"success": true
},
{
"command": "exception",
"duration_ms": 0.058,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.030000000000000002,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.026,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0091",
"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)"
],
"execution_message": {
"success": true,
"result": {
"status_err": "Status update failed",
"status_result": null
},
"variables": {
"order_id": "1",
"status": "shipped",
"oid": 1,
"new_status": "shipped",
"ormAccessUpdate(connector, \"UPDATE orders SET status": "'%s' WHERE id=1\" % new_status, status_result)",
"err": "No error detected",
"_status": 400,
"status_err": "Status update failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.19799999999999998,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.115,
"success": true
},
{
"command": "try",
"duration_ms": 0.376,
"success": true
},
{
"command": "assign",
"duration_ms": 0.134,
"success": true
},
{
"command": "exception",
"duration_ms": 0.1,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 400
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0092",
"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)"
],
"execution_message": {
"success": true,
"result": {
"counter_result": null
},
"variables": {
"article_id": "1",
"aid": 1,
"ormAccessUpdate(connector, \"UPDATE articles SET views": "views+1 WHERE id=1\", counter_result)",
"err": "No error detected",
"counter_result": null
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.177,
"success": true
},
{
"command": "try",
"duration_ms": 0.039,
"success": true
},
{
"command": "assign",
"duration_ms": 0.16899999999999998,
"success": true
},
{
"command": "exception",
"duration_ms": 0.057,
"success": true
},
{
"command": "assign",
"duration_ms": 0.056,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0093",
"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)"
],
"execution_message": {
"success": true,
"result": {
"reset_err": "Password reset failed",
"reset_result": null
},
"variables": {
"user_id": "1",
"new_hash": "abc123hash",
"uid": 1,
"pwd_hash": "abc123hash",
"ormAccessUpdate(connector, \"UPDATE users SET password_hash": "'%s' WHERE id=1\" % pwd_hash, reset_result)",
"err": "No error detected",
"_status": 500,
"reset_err": "Password reset failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.202,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.122,
"success": true
},
{
"command": "try",
"duration_ms": 0.049,
"success": true
},
{
"command": "assign",
"duration_ms": 0.453,
"success": true
},
{
"command": "exception",
"duration_ms": 0.081,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.063,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.037,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.028,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0094",
"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)"
],
"execution_message": {
"success": true,
"result": {
"price_err": "Price update failed",
"price_result": null
},
"variables": {
"product_id": "1",
"price": "29.99",
"pid": 1,
"new_price": 29.99,
"ormAccessUpdate(connector, \"UPDATE products SET price": "%s WHERE id=1\" % new_price, price_result)",
"err": "No error detected",
"_status": 422,
"price_err": "Price update failed"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.202,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.068,
"success": true
},
{
"command": "try",
"duration_ms": 0.081,
"success": true
},
{
"command": "assign",
"duration_ms": 0.108,
"success": true
},
{
"command": "exception",
"duration_ms": 0.053,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.045000000000000005,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.041,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.024,
"success": true
}
],
"http_status": 422
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0095",
"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)"
],
"execution_message": {
"success": true,
"result": {
"read_result": null
},
"variables": {
"user_id": "1",
"uid": 1,
"ormAccessUpdate(connector, \"UPDATE notifications SET read": "1 WHERE user_id=1\", read_result)",
"err": "No error detected",
"_status": 500,
"read_result": null
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.5720000000000001,
"success": true
},
{
"command": "try",
"duration_ms": 0.161,
"success": true
},
{
"command": "assign",
"duration_ms": 0.235,
"success": true
},
{
"command": "exception",
"duration_ms": 0.056,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.039,
"success": true
},
{
"command": "assign",
"duration_ms": 0.111,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.047,
"success": true
}
],
"http_status": 500
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0096",
"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)"
],
"execution_message": {
"success": true,
"result": {
"user_name": "Alice"
},
"variables": {
"response": "{\"name\":\"Alice\"}",
"raw_response": {
"name": "Alice"
},
"user_name": "Alice"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.221,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.074,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034999999999999996,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0097",
"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)"
],
"execution_message": {
"success": true,
"result": {
"usd_rate": "1.2"
},
"variables": {
"rates": "{\"usd\":\"1.2\"}",
"rates_response": {
"usd": "1.2"
},
"usd_rate": "1.2"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 1.471,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.087,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0098",
"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)"
],
"execution_message": {
"success": true,
"result": {
"temperature": "15C"
},
"variables": {
"city": "London",
"weather": "{\"temp\":\"15C\"}",
"weather_json": {
"temp": "15C"
},
"temperature": "15C"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.259,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.083,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.075,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.041999999999999996,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0099",
"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)"
],
"execution_message": {
"success": true,
"result": {
"access_token": "tok-abc"
},
"variables": {
"client_id": "app-001",
"token_response": {
"access_token": "tok-abc"
},
"cid": "app-001",
"access_token": "tok-abc"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.228,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.07200000000000001,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.056,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0100",
"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)"
],
"execution_message": {
"success": true,
"result": {
"product_price": "9.99"
},
"variables": {
"sku": "ABC-123",
"product_json": {
"price": "9.99"
},
"product_sku": "ABC-123",
"product_price": "9.99"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 1.1869999999999998,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.914,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.112,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.038,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0101",
"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)"
],
"execution_message": {
"success": true,
"result": {
"account_status": "active"
},
"variables": {
"user_id": "u42",
"profile_json": {
"status": "active"
},
"uid": "u42",
"account_status": "active"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.292,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.089,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.054,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0102",
"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)"
],
"execution_message": {
"success": true,
"result": {
"new_ui_flag": "true"
},
"variables": {
"flags_json": {
"new_ui": "true"
},
"new_ui_flag": "true"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.19,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.061,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.06999999999999999,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0103",
"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)"
],
"execution_message": {
"success": true,
"result": {
"jwt_token": "jwt-abc"
},
"variables": {
"username": "admin",
"login_response": {
"token": "jwt-abc"
},
"uname": "admin",
"jwt_token": "jwt-abc"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.45899999999999996,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.127,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.078,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.041999999999999996,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0104",
"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)"
],
"execution_message": {
"success": true,
"result": {
"txn_id": "txn-001"
},
"variables": {
"amount": "49.99",
"pay_response": {
"transaction_id": "txn-001"
},
"pay_amount": 49.99,
"txn_id": "txn-001"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.179,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.103,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.057,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0105",
"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)"
],
"execution_message": {
"success": true,
"result": {
"new_id": "res-001"
},
"variables": {
"name": "my-resource",
"create_response": {
"id": "res-001"
},
"resource_name": "my-resource",
"new_id": "res-001"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.264,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.087,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.060000000000000005,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.04,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0106",
"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)"
],
"execution_message": {
"success": true,
"result": {
"confirm_code": "200"
},
"variables": {
"event": "purchase",
"evt_response": {
"code": "200"
},
"evt_name": "purchase",
"confirm_code": "200"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.237,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.067,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.075,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0107",
"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)"
],
"execution_message": {
"success": true,
"result": {
"push_token": "ptok-xyz"
},
"variables": {
"device_id": "dev-abc",
"reg_response": {
"push_token": "ptok-xyz"
},
"did": "dev-abc",
"push_token": "ptok-xyz"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.621,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.09899999999999999,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.055,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0108",
"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)"
],
"execution_message": {
"success": true,
"result": {
"ticket_num": "T-001"
},
"variables": {
"subject": "Login issue",
"ticket_response": {
"ticket_number": "T-001"
},
"ticket_subject": "Login issue",
"ticket_num": "T-001"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.23,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.06499999999999999,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.067,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.037,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0109",
"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)"
],
"execution_message": {
"success": true,
"result": {
"result_id": "item-42"
},
"variables": {
"data": "{\"id\":\"item-42\"}",
"json_input": {
"id": "item-42"
},
"result_id": "item-42"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.281,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.08,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.039,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0110",
"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)"
],
"execution_message": {
"success": true,
"result": {
"status_value": "active"
},
"variables": {
"payload": "{\"status\":\"active\"}",
"raw_json": {
"status": "active"
},
"status_value": "active"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.6489999999999999,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.083,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034999999999999996,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0111",
"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)"
],
"execution_message": {
"success": true,
"result": {
"email_result": "test@example.com"
},
"variables": {
"profile": "{\"email\":\"test@example.com\"}",
"profile_data": {
"email": "test@example.com"
},
"email_result": "test@example.com"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.27099999999999996,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.076,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.043000000000000003,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0112",
"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)"
],
"execution_message": {
"success": true,
"result": {
"timeout_val": 30
},
"variables": {
"config": "{\"timeout\":30}",
"config_str": {
"timeout": 30
},
"timeout_val": 30
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.193,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.062,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0113",
"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)"
],
"execution_message": {
"success": true,
"result": {
"error_message": "Not found"
},
"variables": {
"error": "{\"message\":\"Not found\"}",
"error_json": {
"message": "Not found"
},
"error_message": "Not found"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.212,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.063,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.056,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0114",
"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)"
],
"execution_message": {
"success": true,
"result": {
"version": "2.0"
},
"variables": {
"response": "{\"version\":\"2.0\"}",
"api_resp": {
"version": "2.0"
},
"version": "2.0"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.192,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.058,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0115",
"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)"
],
"execution_message": {
"success": true,
"result": {
"sum_result": 15
},
"variables": {
"n": 5,
"max_n": 5,
"total": 15,
"i": 5,
"sum_result": 15
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.17200000000000001,
"success": true
},
{
"command": "sumRange",
"duration_ms": 0.7829999999999999,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.082,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0116",
"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)"
],
"execution_message": {
"success": true,
"result": {
"final_count": 3
},
"variables": {
"total": 3,
"item_total": 3,
"count": 3,
"i": 3,
"final_count": 3
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.273,
"success": true
},
{
"command": "countItems",
"duration_ms": 0.347,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.067,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0117",
"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)"
],
"execution_message": {
"success": true,
"result": {
"sum_result": 15
},
"variables": {
"n": 5,
"max_n": 5,
"total": 15,
"i": 5,
"sum_result": 15
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.212,
"success": true
},
{
"command": "sumRange",
"duration_ms": 0.328,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.047,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0118",
"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)"
],
"execution_message": {
"success": true,
"result": {
"repeated": "ababab"
},
"variables": {
"str": "ab",
"input_str": "ab",
"result": "ababab",
"i": 3,
"repeated": "ababab"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.245,
"success": true
},
{
"command": "repeatStr",
"duration_ms": 0.30200000000000005,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.048,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0119",
"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)"
],
"execution_message": {
"success": true,
"result": {
"total_result": 10
},
"variables": {
"max": 4,
"upper_bound": 4,
"acc": 10,
"j": 4,
"total_result": 10
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.17300000000000001,
"success": true
},
{
"command": "runningTotal",
"duration_ms": 0.749,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.07100000000000001,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0120",
"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)"
],
"execution_message": {
"success": true,
"result": {
"triple_result": 12
},
"variables": {
"base": 4,
"base_num": 4,
"result": 12,
"i": 3,
"triple_result": 12
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.19699999999999998,
"success": true
},
{
"command": "triple",
"duration_ms": 0.3,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.063,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0121",
"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)"
],
"execution_message": {
"success": true,
"result": {
"count": 1
},
"variables": {
"ormAccessSelect(connector, \"SELECT id FROM products WHERE active": "1\", product_ids)",
"total_products": 0,
"count": 1,
"i": 0
},
"assertion_result": true,
"logs": [
{
"command": "assign",
"duration_ms": 0.09000000000000001,
"success": true
},
{
"command": "getListLen",
"duration_ms": 0.164,
"success": true
},
{
"command": "assign",
"duration_ms": 0.08399999999999999,
"success": true
},
{
"command": "startLoop",
"duration_ms": 0.40900000000000003,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.094,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0122",
"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)"
],
"execution_message": {
"success": true,
"result": {
"num_orders": 0
},
"variables": {
"ormAccessSelect(connector, \"SELECT total FROM orders WHERE status": "'complete'\", order_totals)",
"num_orders": 0
},
"assertion_result": true,
"logs": [
{
"command": "assign",
"duration_ms": 0.16699999999999998,
"success": true
},
{
"command": "getListLen",
"duration_ms": 0.23399999999999999,
"success": true
},
{
"command": "startLoop",
"duration_ms": 0.027,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.078,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0123",
"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)"
],
"execution_message": {
"success": true,
"result": {
"user_count": 0
},
"variables": {
"null": [],
"user_count": 0
},
"assertion_result": true,
"logs": [
{
"command": "ormAccessSelect",
"duration_ms": 0.257,
"success": true
},
{
"command": "getListLen",
"duration_ms": 0.085,
"success": true
},
{
"command": "startLoop",
"duration_ms": 0.051,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.047,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0124",
"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)"
],
"execution_message": {
"success": true,
"result": {
"error_count": 0
},
"variables": {
"null": [],
"log_count": 0,
"error_count": 0
},
"assertion_result": true,
"logs": [
{
"command": "ormAccessSelect",
"duration_ms": 0.201,
"success": true
},
{
"command": "getListLen",
"duration_ms": 0.095,
"success": true
},
{
"command": "assign",
"duration_ms": 0.101,
"success": true
},
{
"command": "startLoop",
"duration_ms": 0.013,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.045000000000000005,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0125",
"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)"
],
"execution_message": {
"success": true,
"result": {
"cat_count": 0
},
"variables": {
"ormAccessSelect(connector, \"SELECT name FROM categories WHERE active": "1\", categories)",
"cat_count": 0
},
"assertion_result": true,
"logs": [
{
"command": "assign",
"duration_ms": 0.11299999999999999,
"success": true
},
{
"command": "getListLen",
"duration_ms": 0.213,
"success": true
},
{
"command": "startLoop",
"duration_ms": 0.024,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.041,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0126",
"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)"
],
"execution_message": {
"success": true,
"result": {
"prod_count": 0
},
"variables": {
"category": "electronics",
"cat_filter": "electronics",
"ormAccessSelect(connector, \"SELECT id FROM products WHERE category": "'electronics'\", prod_ids)",
"prod_count": 0
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.206,
"success": true
},
{
"command": "assign",
"duration_ms": 0.132,
"success": true
},
{
"command": "getListLen",
"duration_ms": 0.111,
"success": true
},
{
"command": "startLoop",
"duration_ms": 0.015000000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0127",
"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)"
],
"execution_message": {
"success": true,
"result": {
"doubled": 10
},
"variables": {
"n": 5,
"input_n": 5,
"result": 10,
"doubled": 10
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.214,
"success": true
},
{
"command": "doubleOf",
"duration_ms": 0.17200000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.053,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0128",
"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)"
],
"execution_message": {
"success": true,
"result": {
"formatted": "Result"
},
"variables": {
"value": "42",
"input_val": 42,
"msg": "Result",
"formatted": "Result"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.26699999999999996,
"success": true
},
{
"command": "formatMsg",
"duration_ms": 0.16699999999999998,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.038,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0129",
"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)"
],
"execution_message": {
"success": true,
"result": {
"hash_result": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
},
"variables": {
"data": "hello",
"input_data": "hello",
"hash_result": "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.319,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.12000000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0130",
"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)"
],
"execution_message": {
"success": true,
"result": {
"time_result": "2026-03-31"
},
"variables": {
"now": "2026-03-31",
"time_result": "2026-03-31"
},
"assertion_result": true,
"logs": [
{
"command": "currentTime",
"duration_ms": 0.29300000000000004,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.068,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0131",
"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)"
],
"execution_message": {
"success": true,
"result": {
"clean_result": "hello_world"
},
"variables": {
"input": "hello world",
"raw_input": "hello world",
"cleaned": "hello_world",
"clean_result": "hello_world"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.241,
"success": true
},
{
"command": "sanitize",
"duration_ms": 0.207,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.051,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0132",
"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)"
],
"execution_message": {
"success": true,
"result": {
"result_set": null
},
"variables": {
"status": "active",
"filter_status": "active",
"ormAccessSelect(connector, \"SELECT * FROM users WHERE status": "'active'\", result_set)"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.516,
"success": true
},
{
"command": "if",
"duration_ms": 0.578,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.076,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0133",
"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)"
],
"execution_message": {
"success": true,
"result": {
"user_record": null
},
"variables": {
"user_id": "1",
"uid": 1,
"ormAccessSelect(connector, \"SELECT name FROM users WHERE id": "1\", user_record)"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.202,
"success": true
},
{
"command": "if",
"duration_ms": 0.361,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.051,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0134",
"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)"
],
"execution_message": {
"success": true,
"result": {
"admin_data": null
},
"variables": {
"role": "admin",
"user_role": "admin",
"null": []
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.514,
"success": true
},
{
"command": "if",
"duration_ms": 1.106,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.041,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0135",
"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)"
],
"execution_message": {
"success": true,
"result": {
"page_data": null
},
"variables": {
"page": 1,
"page_num": 1,
"null": []
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.187,
"success": true
},
{
"command": "if",
"duration_ms": 0.41300000000000003,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0136",
"text": "Conditionally query archived or active records based on flag",
"code": "addParam(\"archived\", show_archived)\nif(show_archived, \"true\", \"==\")\n ormAccessSelect(connector, \"SELECT * FROM records WHERE archived=1\", records)\nelse()\n ormAccessSelect(connector, \"SELECT * FROM records WHERE archived=0\", records)\nend()\naddResult(records)",
"test_inputs": {
"archived": "true"
},
"test_list": [
"re.match(r\"^true$\", show_archived)"
],
"execution_message": {
"success": true,
"result": {
"records": null
},
"variables": {
"archived": "true",
"show_archived": true,
"ormAccessSelect(connector, \"SELECT * FROM records WHERE archived": "0\", records)"
},
"assertion_result": false,
"logs": [
{
"command": "addParam",
"duration_ms": 0.201,
"success": true
},
{
"command": "if",
"duration_ms": 0.377,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.063,
"success": true
}
],
"http_status": 200
},
"passed": false,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0137",
"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)"
],
"execution_message": {
"success": true,
"result": {
"insert_result": null,
"count_after": null
},
"variables": {
"name": "Test Item",
"item_name": "Test Item",
"insert_result": null,
"null": []
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.207,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.112,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 0.16699999999999998,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.028,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0138",
"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)"
],
"execution_message": {
"success": true,
"result": {
"new_user_id": null,
"latest_user": null
},
"variables": {
"username": "testuser",
"uname": "testuser",
"new_user_id": null,
"null": []
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.361,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.335,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 0.361,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.088,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.028,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0139",
"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)"
],
"execution_message": {
"success": true,
"result": {
"order_id": null,
"order_detail": null
},
"variables": {
"customer_id": "c42",
"cid": "c42",
"order_id": null,
"ormAccessSelect(connector, \"SELECT * FROM orders WHERE id": "1\", order_detail)"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.225,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.112,
"success": true
},
{
"command": "assign",
"duration_ms": 0.09000000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.07100000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.030000000000000002,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0140",
"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)"
],
"execution_message": {
"success": true,
"result": {
"log_id": null,
"log_count": null
},
"variables": {
"event": "user_login",
"evt": "user_login",
"log_id": null,
"null": []
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.712,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.359,
"success": true
},
{
"command": "ormAccessSelect",
"duration_ms": 0.713,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.054,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.029,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0141",
"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)"
],
"execution_message": {
"success": true,
"result": {
"cat_id": null,
"all_cats": null
},
"variables": {
"category": "Electronics",
"cat_name": "Electronics",
"cat_id": null,
"ormAccessSelect(connector, \"SELECT id, name FROM categories WHERE active": "1\", all_cats)"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.8170000000000001,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 1.011,
"success": true
},
{
"command": "assign",
"duration_ms": 0.281,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.089,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.6920000000000001,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0142",
"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)"
],
"execution_message": {
"success": true,
"result": {
"result": true
},
"variables": {
"target": 5,
"search_target": 5,
"found": true,
"i": 10,
"result": true
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.195,
"success": true
},
{
"command": "findFirst",
"duration_ms": 2.705,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.315,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0143",
"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)"
],
"execution_message": {
"success": true,
"result": {
"matches": 5
},
"variables": {
"threshold": 5,
"thr": 5,
"matches": 5,
"i": 10
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.224,
"success": true
},
{
"command": "assign",
"duration_ms": 0.14200000000000002,
"success": true
},
{
"command": "startLoop",
"duration_ms": 4.567,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.037,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0144",
"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)"
],
"execution_message": {
"success": true,
"result": {
"even_sum": 6
},
"variables": {
"max": 4,
"upper_n": 4,
"total": 6,
"i": 4,
"remainder": 2,
"even_sum": 6
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.19699999999999998,
"success": true
},
{
"command": "sumEven",
"duration_ms": 3.109,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.059,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0145",
"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)"
],
"execution_message": {
"success": true,
"result": {
"above_count": 2
},
"variables": {
"threshold": 3,
"items": 5,
"thr_val": 3,
"max_items": 5,
"above_count": 2,
"i": 5
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.182,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.06999999999999999,
"success": true
},
{
"command": "assign",
"duration_ms": 0.129,
"success": true
},
{
"command": "startLoop",
"duration_ms": 3.335,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.054,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0146",
"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)"
],
"execution_message": {
"success": true,
"result": {
"found_idx": 6
},
"variables": {
"min": 5,
"min_value": 5,
"found_idx": 6,
"i": 10
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 2.028,
"success": true
},
{
"command": "assign",
"duration_ms": 0.15100000000000002,
"success": true
},
{
"command": "startLoop",
"duration_ms": 14.828,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.162,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0147",
"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)"
],
"execution_message": {
"success": true,
"result": {
"result_a": "result_a",
"result_b": "result_b"
},
"variables": {
"task_a": "f47b6023-554e-4eda-98f0-0df366452e83",
"task_b": "b5108367-25ab-41aa-a000-265ddde3a4bd",
"result_a": "result_a",
"result_b": "result_b"
},
"assertion_result": true,
"logs": [
{
"command": "go",
"duration_ms": 0.8899999999999999,
"success": true
},
{
"command": "go",
"duration_ms": 0.78,
"success": true
},
{
"command": "gather",
"duration_ms": 0.037,
"success": true
},
{
"command": "gather",
"duration_ms": 0.013,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.13699999999999998,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.031,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0151",
"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)"
],
"execution_message": {
"success": true,
"result": {
"user_email": "a@b.com",
"user_phone": 123
},
"variables": {
"email": "a@b.com",
"phone": "123",
"user_email": "a@b.com",
"user_phone": 123
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.292,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.08399999999999999,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.037,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0152",
"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)"
],
"execution_message": {
"success": true,
"result": {
"target_url": "https://api.example.com/data"
},
"variables": {
"url": "https://api.example.com/data",
"target_url": "https://api.example.com/data"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.241,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.05,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0153",
"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)"
],
"execution_message": {
"success": true,
"result": {
"ep1_result": "ep1_data",
"ep2_result": "ep2_data"
},
"variables": {
"ep1_result": "ep1_data",
"ep2_result": "ep2_data"
},
"assertion_result": true,
"logs": [
{
"command": "task1",
"duration_ms": 0.096,
"success": true
},
{
"command": "task2",
"duration_ms": 0.06899999999999999,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.115,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.029,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0154",
"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)"
],
"execution_message": {
"success": true,
"result": {
"status1": "healthy",
"status2": "healthy"
},
"variables": {
"status1": "healthy",
"status2": "healthy"
},
"assertion_result": true,
"logs": [
{
"command": "checkService1",
"duration_ms": 0.11699999999999999,
"success": true
},
{
"command": "checkService2",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.128,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0155",
"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)"
],
"execution_message": {
"success": true,
"result": {
"uid": "u5",
"profile_result": "profile_data"
},
"variables": {
"user_id": "u5",
"uid": "u5",
"profile_result": "profile_data"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.507,
"success": true
},
{
"command": "fetchProfile",
"duration_ms": 0.156,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.079,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.029,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0156",
"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)"
],
"execution_message": {
"success": true,
"result": {
"event_payload": "event_data"
},
"variables": {
"payload": "event_data",
"event_payload": "event_data"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.263,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.07200000000000001,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0157",
"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)"
],
"execution_message": {
"success": true,
"result": {
"notif_msg": "Alert!"
},
"variables": {
"message": "Alert!",
"notif_msg": "Alert!"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.27399999999999997,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.049,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0158",
"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)"
],
"execution_message": {
"success": true,
"result": {
"event_name": "checkout"
},
"variables": {
"event": "checkout",
"event_name": "checkout"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.298,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.051,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0159",
"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)"
],
"execution_message": {
"success": true,
"result": {
"oid": "ORD-999"
},
"variables": {
"order_id": "ORD-999",
"oid": "ORD-999"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.254,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.078,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0160",
"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)"
],
"execution_message": {
"success": true,
"result": {
"result_a": "result_a",
"result_b": "result_b"
},
"variables": {
"result_a": "result_a",
"result_b": "result_b"
},
"assertion_result": true,
"logs": [
{
"command": "fetchA",
"duration_ms": 0.088,
"success": true
},
{
"command": "fetchB",
"duration_ms": 0.04,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.14300000000000002,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.036000000000000004,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0161",
"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)"
],
"execution_message": {
"success": true,
"result": {
"uid": "u10",
"profile": "profile_data"
},
"variables": {
"user_id": "u10",
"uid": "u10",
"profile": "profile_data",
"prefs": "prefs_data"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.21000000000000002,
"success": true
},
{
"command": "getProfile",
"duration_ms": 0.10900000000000001,
"success": true
},
{
"command": "getPrefs",
"duration_ms": 0.052,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.058,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.029,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0162",
"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)"
],
"execution_message": {
"success": true,
"result": {
"r1": "table1_data",
"r2": "table2_data"
},
"variables": {
"r1": "table1_data",
"r2": "table2_data"
},
"assertion_result": true,
"logs": [
{
"command": "queryTable1",
"duration_ms": 0.14200000000000002,
"success": true
},
{
"command": "queryTable2",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.126,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0163",
"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)"
],
"execution_message": {
"success": true,
"result": {
"step1_result": "step1_done",
"step2_result": "step2_done"
},
"variables": {
"input": "data",
"raw_input": "data",
"step1_result": "step1_done",
"step2_result": "step2_done"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.244,
"success": true
},
{
"command": "processStep1",
"duration_ms": 0.179,
"success": true
},
{
"command": "processStep2",
"duration_ms": 0.029,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.057,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.028,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0164",
"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)"
],
"execution_message": {
"success": true,
"result": {
"pwd_hash": "89e01536ac207279409d4de1e5253e01f4a1769e696db0d6062ca9b8f56767c8"
},
"variables": {
"password": "mypassword",
"raw_pwd": "mypassword",
"pwd_hash": "89e01536ac207279409d4de1e5253e01f4a1769e696db0d6062ca9b8f56767c8"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.316,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.067,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0165",
"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)"
],
"execution_message": {
"success": true,
"result": {
"data_checksum": "3d08a39c7133266e411de2db82ea841ec638d9395da9556fd9f39210e89942ab"
},
"variables": {
"data": "important_data",
"payload": "important_data",
"data_checksum": "3d08a39c7133266e411de2db82ea841ec638d9395da9556fd9f39210e89942ab"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.27599999999999997,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.089,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.04,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0166",
"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)"
],
"execution_message": {
"success": true,
"result": {
"cache_key": "f6c80f39edacded53548b613373490ed28b585223cb965a0a2a36a0edc55c7e2"
},
"variables": {
"query": "search_term",
"cache_input": "search_term",
"cache_key": "f6c80f39edacded53548b613373490ed28b585223cb965a0a2a36a0edc55c7e2"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.243,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.544,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.064,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0167",
"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)"
],
"execution_message": {
"success": true,
"result": {
"payload_sig": "a843a9140d34440cab8324baf813d69c7503238a563af7ac836d718d1ce41fb4"
},
"variables": {
"payload": "data_to_sign",
"sign_input": "data_to_sign",
"payload_sig": "a843a9140d34440cab8324baf813d69c7503238a563af7ac836d718d1ce41fb4"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.199,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.056,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0168",
"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)"
],
"execution_message": {
"success": true,
"result": {
"auth_result": "authenticated"
},
"variables": {
"password": "password",
"raw_pwd": "password",
"input_hash": "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8",
"stored_hash": "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8",
"auth_result": "authenticated"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.33,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.06499999999999999,
"success": true
},
{
"command": "assign",
"duration_ms": 0.132,
"success": true
},
{
"command": "if",
"duration_ms": 1.637,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.068,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0169",
"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)"
],
"execution_message": {
"success": true,
"result": {
"valid": "True"
},
"variables": {
"data": "test",
"expected": "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
"raw_data": "test",
"expected_hash": "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
"computed_hash": "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08",
"valid": "True"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.21000000000000002,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.066,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.054,
"success": true
},
{
"command": "if",
"duration_ms": 0.24899999999999997,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0170",
"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)"
],
"execution_message": {
"success": true,
"result": {
"access": "granted"
},
"variables": {
"api_key": "my-api-key",
"raw_key": "my-api-key",
"key_hash": "2e35b6583bdba19c898a7ca545bac207502222f6167a59924ae3953a9231c787",
"_status": 200,
"access": "granted"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.203,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.093,
"success": true
},
{
"command": "if",
"duration_ms": 0.35300000000000004,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.032,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0171",
"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)"
],
"execution_message": {
"success": true,
"result": {
"processed": "True"
},
"variables": {
"document": "important doc",
"doc_content": "important doc",
"doc_hash": "ff8ab2ba53ac24b061b20621c7064f55fdf97262163145ec42965709e1b2330b",
"processed": "True",
"doc_id": "ff8ab2ba53ac24b061b20621c7064f55fdf97262163145ec42965709e1b2330b"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.522,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.114,
"success": true
},
{
"command": "if",
"duration_ms": 1.321,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.055,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0172",
"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)"
],
"execution_message": {
"success": true,
"result": {
"hash_val": "d1de430faaef87af7a07d42c6f92db8e"
},
"variables": {
"data": "hello",
"input_data": "hello",
"hash_val": "d1de430faaef87af7a07d42c6f92db8e"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.213,
"success": true
},
{
"command": "encodeMD5",
"duration_ms": 0.097,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.036000000000000004,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0173",
"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)"
],
"execution_message": {
"success": true,
"result": {
"file_fp": "7f0b6bb0b7e951b7fd2b2a4a326297e1"
},
"variables": {
"content": "file_data",
"file_content": "file_data",
"file_fp": "7f0b6bb0b7e951b7fd2b2a4a326297e1"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.28600000000000003,
"success": true
},
{
"command": "encodeMD5",
"duration_ms": 0.116,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.04,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0174",
"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)"
],
"execution_message": {
"success": true,
"result": {
"gravatar": "40c27bdce4fa810f3b476676ff654f3c"
},
"variables": {
"email": "user@example.com",
"user_email": "user@example.com",
"gravatar": "40c27bdce4fa810f3b476676ff654f3c"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.203,
"success": true
},
{
"command": "encodeMD5",
"duration_ms": 0.077,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0175",
"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)"
],
"execution_message": {
"success": true,
"result": {
"response": {
"ok": "ok",
"Success": "Success"
}
},
"variables": {
"status": "ok",
"message": "Success",
"resp_status": "ok",
"resp_msg": "Success",
"response": {
"ok": "ok",
"Success": "Success"
}
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.31,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.09899999999999999,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.061,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.079,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.052,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.052,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0176",
"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)"
],
"execution_message": {
"success": true,
"result": {
"profile_json": {
"Alice": "Alice",
"alice@example.com": "alice@example.com"
}
},
"variables": {
"name": "Alice",
"email": "alice@example.com",
"user_name": "Alice",
"user_email": "alice@example.com",
"profile_json": {
"Alice": "Alice",
"alice@example.com": "alice@example.com"
}
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.207,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.062,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.046,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.07100000000000001,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.061,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.041999999999999996,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0177",
"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)"
],
"execution_message": {
"success": true,
"result": {
"meta_obj": {
"1": 1,
"100": 100
}
},
"variables": {
"page": 1,
"total": 100,
"page_num": 1,
"total_records": 100,
"meta_obj": {
"1": 1,
"100": 100
}
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.20900000000000002,
"success": true
},
{
"command": "addParam",
"duration_ms": 0.067,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.047,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.062,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.422,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.08399999999999999,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0178",
"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)"
],
"execution_message": {
"success": true,
"result": {
"output_json": {
"greeting": "Hello World"
}
},
"variables": {
"input_json": "{\"name\":\"World\"}",
"raw_json": {
"name": "World"
},
"extracted_name": "World",
"output_json": {
"greeting": "Hello World"
}
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.231,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.062,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.207,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.14400000000000002,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0179",
"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)"
],
"execution_message": {
"success": true,
"result": {
"enriched": {
"price": "9.99",
"currency": "USD"
}
},
"variables": {
"product_json": "{\"price\":\"9.99\"}",
"prod_json": {
"price": "9.99"
},
"prod_price": "9.99",
"enriched": {
"price": "9.99",
"currency": "USD"
}
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.244,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.067,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.041999999999999996,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.056,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.044,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.062,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0180",
"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)"
],
"execution_message": {
"success": true,
"result": {
"clean_output": {
"id": "u1",
"role": "admin"
}
},
"variables": {
"api_response": "{\"user_id\":\"u1\",\"role\":\"admin\"}",
"api_json": {
"user_id": "u1",
"role": "admin"
},
"uid": "u1",
"user_role": "admin",
"clean_output": {
"id": "u1",
"role": "admin"
}
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.225,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.079,
"success": true
},
{
"command": "variableFromJSON",
"duration_ms": 0.033,
"success": true
},
{
"command": "addVar",
"duration_ms": 0.059,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.061,
"success": true
},
{
"command": "AddvariableToJSON",
"duration_ms": 0.044,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.028,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0181",
"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)"
],
"execution_message": {
"success": true,
"result": {
"insert_result": null
},
"variables": {
"action": "login",
"audit_action": "login",
"current_time": "2026-03-31 13:16:02",
"insert_result": null
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.217,
"success": true
},
{
"command": "getDateTime",
"duration_ms": 0.205,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.12000000000000001,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0182",
"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)"
],
"execution_message": {
"success": true,
"result": {
"evt_id": null
},
"variables": {
"event_name": "sale_started",
"evt": "sale_started",
"evt_timestamp": 1774962962.627832,
"evt_id": null
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.222,
"success": true
},
{
"command": "getDateTime",
"duration_ms": 0.093,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.866,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.094,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0183",
"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)"
],
"execution_message": {
"success": true,
"result": {
"sub_id": null
},
"variables": {
"user_id": "u99",
"uid": "u99",
"expires_at": 1775049362.974839,
"sub_id": null
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.26699999999999996,
"success": true
},
{
"command": "getDateTime",
"duration_ms": 0.108,
"success": true
},
{
"command": "ormAccessInsert",
"duration_ms": 0.441,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.068,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0185",
"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)"
],
"execution_message": {
"success": true,
"result": {
"active_users": "active_cnt",
"total_revenue": "revenue"
},
"variables": {
"users_task": "b8a8888f-4054-412e-b925-02836144bd7f",
"ormAccessSelect(connector, \"SELECT COUNT(*) as cnt FROM users WHERE active": "1\", active_cnt)",
"revenue_task": "279a7f78-df95-4108-b297-aff009c57c16",
"active_users": "active_cnt",
"ormAccessSelect(connector, \"SELECT SUM(amount) as total FROM payments WHERE month": "1\", revenue)",
"total_revenue": "revenue"
},
"assertion_result": true,
"logs": [
{
"command": "go",
"duration_ms": 1.2930000000000001,
"success": true
},
{
"command": "go",
"duration_ms": 0.252,
"success": true
},
{
"command": "gather",
"duration_ms": 0.017,
"success": true
},
{
"command": "gather",
"duration_ms": 0.651,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.112,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.029,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0187",
"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)"
],
"execution_message": {
"success": true,
"result": {
"ts_result": 1774962963.612195
},
"variables": {
"ts": 1774962963.612195,
"ts_result": 1774962963.612195
},
"assertion_result": true,
"logs": [
{
"command": "currentTimestamp",
"duration_ms": 0.301,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.048,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0189",
"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)"
],
"execution_message": {
"success": true,
"result": {
"nonce": 1774962964.029056
},
"variables": {
"nonce_ts": 1774962964.029056,
"nonce": 1774962964.029056
},
"assertion_result": true,
"logs": [
{
"command": "generateNonce",
"duration_ms": 0.328,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.051,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0190",
"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)"
],
"execution_message": {
"success": true,
"result": {
"accum": 27
},
"variables": {
"threshold": 7,
"thr": 7,
"accum": 27,
"i": 10
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.16899999999999998,
"success": true
},
{
"command": "assign",
"duration_ms": 0.148,
"success": true
},
{
"command": "startLoop",
"duration_ms": 2.935,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.057,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0191",
"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)"
],
"execution_message": {
"success": true,
"result": {
"matches": 3
},
"variables": {
"min_val": 3,
"min_v": 3,
"matches": 3,
"i": 5
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.221,
"success": true
},
{
"command": "assign",
"duration_ms": 0.126,
"success": true
},
{
"command": "startLoop",
"duration_ms": 3.5109999999999997,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.039,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0192",
"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)"
],
"execution_message": {
"success": true,
"result": {
"result": 6
},
"variables": {
"multiplier": 2,
"mult": 2,
"result": 6,
"i": 5
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.223,
"success": true
},
{
"command": "assign",
"duration_ms": 0.118,
"success": true
},
{
"command": "startLoop",
"duration_ms": 2.535,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.049,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0194",
"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)"
],
"execution_message": {
"success": true,
"result": {
"new_password": "tqPz0Mgmu3w6"
},
"variables": {
"new_password": "tqPz0Mgmu3w6"
},
"assertion_result": true,
"logs": [
{
"command": "randomString",
"duration_ms": 1.365,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.083,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0195",
"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)"
],
"execution_message": {
"success": true,
"result": {
"salt": "5Ubiqret3gjhj28B",
"secure_hash": "9e847ddd280a68051442b8eccb5381896dfe54b02825951ff8316c4c54a9c13f"
},
"variables": {
"salt": "5Ubiqret3gjhj28B",
"secure_hash": "9e847ddd280a68051442b8eccb5381896dfe54b02825951ff8316c4c54a9c13f"
},
"assertion_result": true,
"logs": [
{
"command": "randomString",
"duration_ms": 1.758,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.134,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.027,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0196",
"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)"
],
"execution_message": {
"success": true,
"result": {
"nonce": "a2374d20",
"request_sig": "fb74596e6cb6296e70e8671a499b86982d99b1701fc4e0da6b62c2e7d74cf90f"
},
"variables": {
"payload": "req_data",
"sign_payload": "req_data",
"nonce": "a2374d20",
"nonce_input": "req_dataa2374d20",
"request_sig": "fb74596e6cb6296e70e8671a499b86982d99b1701fc4e0da6b62c2e7d74cf90f"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.21000000000000002,
"success": true
},
{
"command": "randomString",
"duration_ms": 0.62,
"success": true
},
{
"command": "assign",
"duration_ms": 0.415,
"success": true
},
{
"command": "encodeSHA256",
"duration_ms": 0.11299999999999999,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.067,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.029,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0197",
"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)"
],
"execution_message": {
"success": true,
"result": {
"page_slug": "Hello-World"
},
"variables": {
"title": "Hello World",
"page_title": "Hello World",
"slug": "Hello-World",
"page_slug": "Hello-World"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.214,
"success": true
},
{
"command": "slugify",
"duration_ms": 0.194,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.033,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0198",
"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)"
],
"execution_message": {
"success": true,
"result": {
"clean_filename": "my_file.txt"
},
"variables": {
"filename": "my file.txt",
"raw_filename": "my file.txt",
"safe_name": "my_file.txt",
"clean_filename": "my_file.txt"
},
"assertion_result": true,
"logs": [
{
"command": "addParam",
"duration_ms": 0.206,
"success": true
},
{
"command": "sanitizeFilename",
"duration_ms": 0.18100000000000002,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.034,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
},
{
"source_file": "mbpp_avap_prior.json",
"task_id": "PRIOR-0200",
"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)"
],
"execution_message": {
"success": true,
"result": {
"users_result": "users"
},
"variables": {
"users_task": "3eda7d0c-f92d-42d5-81b7-5adcc5b7d10c",
"ormAccessSelect(connector, \"SELECT id, name FROM users WHERE active": "1 LIMIT 20\", users)",
"users_result": "users"
},
"assertion_result": true,
"logs": [
{
"command": "go",
"duration_ms": 1.119,
"success": true
},
{
"command": "gather",
"duration_ms": 0.029,
"success": true
},
{
"command": "addResult",
"duration_ms": 0.132,
"success": true
}
],
"http_status": 200
},
"passed": true,
"error": "",
"Local_Language_Server_Execution": ""
}
]
Reference in New Issue View Git Blame Copy Permalink