How to use postprocess method in autotest

Best Python code snippet using autotest_python

json.js

Source:json.js Github

copy

Full Screen

1/​/​ Generated automatically by nearley, version 2.20.12/​/​ http:/​/​github.com/​Hardmath123/​nearley3(function () {4function id(x) { return x[0]; }5 /​/​console.clear()6 const lexer = require('./​lexer');7 let log = console.log.bind(console)8const fs = require('fs');9const required = (functionName, argumentName, item, type) => {10 if (Type.isUndefined(item)) {11 Type.ArgumentError(`"${argumentName}" is required for "${functionName}" function, but none is provided.`);12 }13 else if (type && type != 'any') {14 if (typeof type === 'string' && Type(item) !== type15 || Array.isArray(type) && !type.includes(Type(item)))16 Type.ArgumentError(`"${argumentName}" at "${functionName}()" must be typeof "${typeof type === 'string' ? type : type.join('/​')}", got "${Type(item)}" instead.`);17 }18}19const localVariables = {};20const variables = {21 $this: null22};23const functions = {24 /​/​ debugging25 error (message) {26 required('error', 'message', message);27 console.error('>>> ' + message)28 return message29 },30 log (message) {31 required('log', 'message', message);32 log('>>> ' + message)33 return message34 },35 /​/​ array <=> string36 join (args, separator) {37 required('join', 'First argument', args, 'array');38 if (args.length === 0)39 return '';40 let result = '';41 args.map(i => functions.String(i));42 return args.join(43 separator !== undefined ? functions.String(separator)44 : undefined45 )46 },47 split (string, separator = '') {48 required('split', 'First argument', string, 'string');49 required('split', 'Second argument', separator, 'string');50 return string.split(separator)51 },52 /​/​ math operations53 sqrt (number) {54 required('sqrt', 'First argument', number, 'number');55 return Math.sqrt(number)56 },57 pow (x, y) {58 required('pow', 'First argument', x, 'number');59 required('pow', 'Second argument', y, 'number');60 return Math.pow(x, y)61 },62 length (item) {63 required('length', 'First argument', item, ['array', 'object', 'string']);64 if (Type.isString(item))65 return item.length;66 else {67 return Object.keys(item).length68 }69 },70 random (min, max) {71 if (min === undefined) {72 return +Math.random().toFixed(2)73 } else if (max === undefined) {74 /​/​ max = min75 return ~~(Math.random() * min)76 } else {77 if (min > max)78 return 0;79 return ~~(Math.random() * (max - min) + min)80 }81 },82 abs (number) {83 required('abs', 'First argument', number, 'number')84 return Math.abs(number) /​/​ bitwise | turn anything inside the () into a number85 },86 invert (hex) {87 required('invert', 'First argument', hex, 'hex')88 return invertHex(hex);89 },90 round (number) {91 required('round', 'First argument', number, 'number')92 return Math.round(number)93 },94 sum (first, second, ...rest) {95 required('sum', 'First argument', first, 'number');96 required('sum', 'Second argument', second, 'number');97 for (let i = 0; i < rest.length; i++) {98 let j = rest[i];99 required('sum', 'All arguments', j, 'number');100 if (j < 0) rest[i] = '(' + rest[i] + ')'101 }102 return eval(`(${first})+(${second})+${rest.length ? rest.join('+') : 0}`);103 },104 reduce (first, second, ...rest) {105 required('sum', 'First argument', first, 'number');106 required('sum', 'Second argument', second, 'number');107 for (let i = 0; i < rest.length; i++) {108 let j = rest[i];109 required('sum', 'All arguments', j, 'number');110 if (j < 0) rest[i] = '(' + rest[i] + ')'111 }112 return eval(`(${first})-(${second})-${rest.length ? rest.join('-') : 0}`);113 },114 multiply (first, second, ...rest) {115 required('sum', 'First argument', first, 'number');116 required('sum', 'Second argument', second, 'number');117 for (let i = 0; i < rest.length; i++) {118 let j = rest[i];119 required('sum', 'All arguments', j, 'number');120 if (j < 0) rest[i] = '(' + rest[i] + ')'121 }122 return eval(`(${first})*(${second})*${rest.length ? rest.join('*') : 1}`);123 },124 divide (first, second, ...rest) {125 required('sum', 'First argument', first, 'number');126 required('sum', 'Second argument', second, 'number');127 if (second === 0)128 Type.ArgumentError(`Function "divide" may accept only the first argument with a value 0.`);129 for (let i = 0; i < rest.length; i++) {130 let j = rest[i];131 required('sum', 'All arguments', j, 'number');132 if (j === 0)133 Type.ArgumentError(`Function "divide()" may accept value 0 only for the first argument.`);134 if (j < 0) rest[i] = '(' + rest[i] + ')'135 }136 return eval(`(${first})/​(${second})/​${rest.length ? rest.join('/​') : 1}`);137 },138 /​/​ type convert139 String (item) {140 required('String', 'At least one argument', item)141 switch (Type(item)) {142 case 'object':143 case 'array':144 return JSON.stringify(item);145 default:146 return item + '';147 }148 },149 Number (item) {150 required('Number', 'At least one argument', item)151 return (item)|0 /​/​ bitwise | turn anything inside the () into a number152 },153 Boolean (item) {154 required('Boolean', 'At least one argument', item)155 return !!item156 },157 Array (item) {158 required('Array', 'At least one argument', item)159 switch (Type(item)) {160 case 'string':161 return item.split('');162 case 'object':163 return Object.values(item);164 /​*case 'number':165 case 'null':166 case 'boolean':167 case 'hex':168 case 'array':*/​169 default:170 return [item];171 }172 return []173 },174 Object (item) {175 required('Object', 'At least one argument', item)176 let key = Type(item);177 if (key === 'string')178 try {179 return JSON.parse(item)180 } catch (err) {}181 let obj = {}182 obj[key] = item183 return obj;184 },185 /​/​ type check186 isNumber (item) {187 required('isNumber', 'At least one argument', item);188 return Type(item) == 'number'189 },190 isString (item) {191 required('isString', 'At least one argument', item);192 return Type(item) == 'string' || Type(item) == 'hex'193 },194 isArray (item) {195 required('isArray', 'At least one argument', item);196 return Type(item) == 'array'197 },198 isNull (item) {199 required('isNull', 'At least one argument', item);200 return item === null;201 },202 isHex (item) {203 required('isHex', 'At least one argument', item);204 return Type(item) == 'hex';205 },206 /​/​ array/​object interactions207 push (array, ...rest) {208 required('push', 'First argument', array, 'array');209 if (rest.length)210 for (let i = 0; i < rest.length; i++) {211 let j = rest[i];212 array.push(j);213 }214 else array.push(null)215 return array;216 },217 insert (target, insertable) {218 required('insert', 'First argument', target, ['object', 'array']);219 if (Type.isObject(target)) {220 required('insert', 'Second argument', insertable, 'object');221 return Object.assign(target, insertable);222 } else {223 required('insert', 'Second argument', insertable, 'array');224 return [...target, ...insertable];225 }226 },227 slice (target, start, end) {228 required('slice', 'First argument', target, ['array', 'string']);229 required('slice', 'Second argument', start, 'number');230 if (end === undefined) end = target.length231 else if (typeof end !== 'number') {232 required('slice', 'Third argument', end, 'number');233 }234 let result = null;235 return target.slice(start, end)236 },237 remove (target, item) {238 required('remove', 'First argument', target, ['string', 'object', 'array']);239 let result = null;240 if (Type.isObject(target)) {241 required('remove', 'Second argument', item, 'string');242 result = target[item]243 delete target[item];244 }245 else {246 required('remove', 'Second argument', item, 'number');247 if (Type.isArray(target)) {248 result = target.splice(item, 1)[0]249 } else {250 result = target.split('').splice(item, 1).join('')251 }252 }253 return result === undefined ? null : result;254 },255 reverse (target) {256 required('remove', 'First argument', target, ['string', 'array']);257 if (Type.isString(target)) {258 return target.split('').reverse().join('')259 }260 return target.reverse()261 }262};263/​/​$this.variables = variables;264const Type = require('./​Type')265function storeVariable (varName, value) {266 variables[varName] = value;267 return varName268}269function getArrayItem(item) {270 return item === undefined ? null : item;271}272function getValue(varName) {273 if (varName in variables) {274 return variables[varName]275 }276 /​/​console.warn(new Error(`${varName} is not defined. undefined is returned instead.`))277 /​/​variables[varName] = undefined;278 /​/​return undefined;279}280function extractPair(kv, output) {281 if(kv[0]) { output[kv[0]] = kv[1]; }282}283function extractObject(d) {284 let output = {};285 extractPair(d[2], output);286 for (let i in d[3]) {287 extractPair(d[3][i][3], output);288 }289 return output;290}291function extractArray(d) {292 let output = [d[2]];293 for (let i in d[3]) {294 output.push(d[3][i][3]);295 }296 return output;297}298function invertHex(hex) {299 let n = hex.substr(1);300 if (n.length == 3) n = n[0] + n[0] + n[1] + n[1] + n[2] + n[2];301 return `#${(Number(`0x1${n}`) ^ 0xFFFFFF).toString(16).substr(1).toLowerCase()}`;302}303function readFile (fileName) {304 let content = null;305 try {306 /​/​ content = await fs.readFile(fileName, 'utf-8')307 content = fs.readFileSync(fileName, 'utf-8')308 /​*let p = new sp(function(resolve, reject) {309 resolve(content);310 });311 return p.v*/​312 } catch (err) {313 throw err;314 }315 return content;316}317var grammar = {318 Lexer: lexer,319 ParserRules: [320 {"name": "process", "symbols": ["main"], "postprocess": id},321 {"name": "process", "symbols": [(lexer.has("space") ? {type: "space"} : space)], "postprocess": d => ''},322 {"name": "process", "symbols": [], "postprocess": d => ''},323 {"name": "main$ebnf$1", "symbols": []},324 {"name": "main$ebnf$1$subexpression$1$subexpression$1", "symbols": ["var_assign"]},325 {"name": "main$ebnf$1$subexpression$1", "symbols": ["_", "main$ebnf$1$subexpression$1$subexpression$1"]},326 {"name": "main$ebnf$1", "symbols": ["main$ebnf$1", "main$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},327 {"name": "main", "symbols": ["main$ebnf$1", "json"], "postprocess": d => d[1]},328 {"name": "json$subexpression$1", "symbols": ["object"]},329 {"name": "json$subexpression$1", "symbols": ["array"]},330 {"name": "json$subexpression$1", "symbols": ["string"]},331 {"name": "json$subexpression$1", "symbols": ["number"]},332 {"name": "json$subexpression$1", "symbols": ["boolean"]},333 {"name": "json$subexpression$1", "symbols": ["if"]},334 {"name": "json", "symbols": ["_", "json$subexpression$1", "_"], "postprocess": d => {335 return d[1][0];336 } },337 {"name": "json", "symbols": [{"literal":"("}, "_", "json", "_", {"literal":")"}], "postprocess": d => d[2]},338 {"name": "json", "symbols": ["_", "myNull", "_"], "postprocess": d => null},339 {"name": "html", "symbols": [(lexer.has("htmlContent") ? {type: "htmlContent"} : htmlContent)], "postprocess": d => d[0].value},340 {"name": "varName", "symbols": [(lexer.has("variableName") ? {type: "variableName"} : variableName)], "postprocess": d => d[0].value},341 {"name": "variable", "symbols": ["varName"], "postprocess": (d, l, reject) => {342 if (getValue(d[0]) === undefined) return reject;343 return getValue(d[0])344 } },345 {"name": "variable", "symbols": [{"literal":"("}, "_", "variable", "_", {"literal":")"}], "postprocess": d => d[2]},346 {"name": "var_assign$subexpression$1", "symbols": ["if"]},347 {"name": "var_assign$subexpression$1", "symbols": ["import"]},348 {"name": "var_assign$subexpression$1", "symbols": ["string"]},349 {"name": "var_assign$subexpression$1", "symbols": ["number"]},350 {"name": "var_assign$subexpression$1", "symbols": ["html"]},351 {"name": "var_assign$subexpression$1", "symbols": ["boolean"]},352 {"name": "var_assign$subexpression$1", "symbols": ["object"]},353 {"name": "var_assign$subexpression$1", "symbols": ["array"]},354 {"name": "var_assign$subexpression$1", "symbols": ["myNull"]},355 {"name": "var_assign", "symbols": ["varName", "_", {"literal":"="}, "_", "var_assign$subexpression$1", "_", {"literal":";"}], "postprocess": function(d) {356 storeVariable(d[0], d[4][0]);357 return d[4][0];358 } },359 {"name": "is", "symbols": [{"literal":"is"}], "postprocess": d => "is"},360 {"name": "than", "symbols": [{"literal":"?"}], "postprocess": d => "?"},361 {"name": "than", "symbols": [{"literal":"than"}], "postprocess": d => "?"},362 {"name": "else", "symbols": [{"literal":"else"}], "postprocess": d => ":"},363 {"name": "else", "symbols": [{"literal":":"}], "postprocess": d => ":"},364 {"name": "if", "symbols": ["myNull", "_", "than", "_", "value", "_", "else", "_", "value"], "postprocess": d => d[8]},365 {"name": "if", "symbols": ["myNull", "_", "than", "_", "value"], "postprocess": d => null},366 {"name": "if$subexpression$1", "symbols": ["variable"]},367 {"name": "if$subexpression$1", "symbols": ["string"]},368 {"name": "if$subexpression$1", "symbols": ["number"]},369 {"name": "if$subexpression$1", "symbols": ["boolean"]},370 {"name": "if$subexpression$1", "symbols": ["condition"]},371 {"name": "if$subexpression$1", "symbols": ["object"]},372 {"name": "if$subexpression$1", "symbols": ["array"]},373 {"name": "if", "symbols": ["if$subexpression$1", "_", "than", "_", "value", "_", "else", "_", "value"], "postprocess": d => {374 if (Type.mayBeBoolean(d[0][0]))375 return d[0][0] ? d[4] : d[8]376 else if (Type.isObject(d[0][0]) || Type.isArray(d[0][0]))377 return d[4]378 Type.TypeError('boolean convertable', d[0][0]);379 }},380 {"name": "if$subexpression$2", "symbols": ["variable"]},381 {"name": "if$subexpression$2", "symbols": ["string"]},382 {"name": "if$subexpression$2", "symbols": ["number"]},383 {"name": "if$subexpression$2", "symbols": ["boolean"]},384 {"name": "if$subexpression$2", "symbols": ["ondition"]},385 {"name": "if$subexpression$2", "symbols": ["object"]},386 {"name": "if$subexpression$2", "symbols": ["array"]},387 {"name": "if", "symbols": ["if$subexpression$2", "_", "than", "_", "value"], "postprocess": d => {388 if (Type.mayBeBoolean(d[0][0]))389 return d[0][0] ? d[4] : null390 else if (Type.isObject(d[0][0]) || Type.isArray(d[0][0]))391 return d[4]392 Type.TypeError('boolean convertable', d[0][0]);393 }},394 {"name": "condition", "symbols": ["boolean", "_", {"literal":"=="}, "_", "boolean"], "postprocess": d => d[0] === d[4]},395 {"name": "condition", "symbols": ["string", "_", {"literal":"=="}, "_", "string"], "postprocess": d => d[0] === d[4]},396 {"name": "condition", "symbols": ["myNull", "_", {"literal":"=="}, "_", "myNull"], "postprocess": d => d[0] === d[4]},397 {"name": "condition", "symbols": ["array", "_", {"literal":"=="}, "_", "array"], "postprocess": d => JSON.stringify(d[0]) === JSON.stringify(d[4])},398 {"name": "condition", "symbols": ["object", "_", {"literal":"=="}, "_", "object"], "postprocess": d => JSON.stringify(d[0]) === JSON.stringify(d[4])},399 {"name": "condition", "symbols": ["boolean", "_", {"literal":"!="}, "_", "boolean"], "postprocess": d => d[0] !== d[4]},400 {"name": "condition", "symbols": ["string", "_", {"literal":"!="}, "_", "string"], "postprocess": d => d[0] !== d[4]},401 {"name": "condition", "symbols": ["myNull", "_", {"literal":"!="}, "_", "myNull"], "postprocess": d => d[0] !== d[4]},402 {"name": "condition", "symbols": ["array", "_", {"literal":"!="}, "_", "array"], "postprocess": d => JSON.stringify(d[0]) !== JSON.stringify(d[4])},403 {"name": "condition", "symbols": ["object", "_", {"literal":"!="}, "_", "object"], "postprocess": d => JSON.stringify(d[0]) !== JSON.stringify(d[4])},404 {"name": "condition", "symbols": ["number", "_", {"literal":"=="}, "_", "number"], "postprocess": d => d[0] === d[4]},405 {"name": "condition", "symbols": ["number", "_", {"literal":"!="}, "_", "number"], "postprocess": d => d[0] !== d[4]},406 {"name": "condition", "symbols": ["number", "_", {"literal":">"}, "_", "number"], "postprocess": d => d[0] > d[4]},407 {"name": "condition", "symbols": ["number", "_", {"literal":"<"}, "_", "number"], "postprocess": d => d[0] < d[4]},408 {"name": "condition", "symbols": ["number", "_", {"literal":">="}, "_", "number"], "postprocess": d => d[0] >= d[4]},409 {"name": "condition", "symbols": ["number", "_", {"literal":"<="}, "_", "number"], "postprocess": d => d[0] <= d[4]},410 {"name": "condition", "symbols": ["condition", "_", (lexer.has("logical_and") ? {type: "logical_and"} : logical_and), "_", "condition"], "postprocess": d => d[0] && d[4]},411 {"name": "condition", "symbols": ["condition", "_", (lexer.has("logical_or") ? {type: "logical_or"} : logical_or), "_", "condition"], "postprocess": d => d[0] || d[4]},412 {"name": "condition", "symbols": ["conditionalValues", "_", (lexer.has("logical_and") ? {type: "logical_and"} : logical_and), "_", "conditionalValues"], "postprocess": d => d[0] && d[4]},413 {"name": "condition", "symbols": ["condition", "_", (lexer.has("logical_and") ? {type: "logical_and"} : logical_and), "_", "conditionalValues"], "postprocess": d => d[0] && d[4]},414 {"name": "condition", "symbols": ["conditionalValues", "_", (lexer.has("logical_and") ? {type: "logical_and"} : logical_and), "_", "condition"], "postprocess": d => d[0] && d[4]},415 {"name": "condition", "symbols": ["conditionalValues", "_", (lexer.has("logical_or") ? {type: "logical_or"} : logical_or), "_", "conditionalValues"], "postprocess": d => d[0] || d[4]},416 {"name": "condition", "symbols": ["conditionalValues", "_", (lexer.has("logical_or") ? {type: "logical_or"} : logical_or), "_", "condition"], "postprocess": d => d[0] || d[4]},417 {"name": "condition", "symbols": ["condition", "_", (lexer.has("logical_or") ? {type: "logical_or"} : logical_or), "_", "conditionalValues"], "postprocess": d => d[0] || d[4]},418 {"name": "conditionalValues$subexpression$1", "symbols": ["string"]},419 {"name": "conditionalValues$subexpression$1", "symbols": ["number"]},420 {"name": "conditionalValues$subexpression$1", "symbols": ["myNull"]},421 {"name": "conditionalValues$subexpression$1", "symbols": ["array"]},422 {"name": "conditionalValues$subexpression$1", "symbols": ["object"]},423 {"name": "conditionalValues$subexpression$1", "symbols": ["boolean"]},424 {"name": "conditionalValues", "symbols": ["conditionalValues$subexpression$1"], "postprocess": d => d[0][0]},425 {"name": "conditionalValues", "symbols": [{"literal":"("}, "_", "if", "_", {"literal":")"}], "postprocess": d => d[2]},426 {"name": "conditionalValues", "symbols": [{"literal":"("}, "_", "conditionalValues", "_", {"literal":")"}], "postprocess": d => d[2]},427 {"name": "number", "symbols": [(lexer.has("number") ? {type: "number"} : number)], "postprocess": d => parseFloat(d[0].value)},428 {"name": "number", "symbols": [{"literal":"PI"}], "postprocess": d => 3.1415926536},429 {"name": "number", "symbols": [{"literal":"E"}], "postprocess": d => 2.7182818285},430 {"name": "number$subexpression$1", "symbols": ["objectItem"]},431 {"name": "number$subexpression$1", "symbols": ["arrayItem"]},432 {"name": "number$subexpression$1", "symbols": ["variable"]},433 {"name": "number$subexpression$1", "symbols": ["function"]},434 {"name": "number", "symbols": ["number$subexpression$1"], "postprocess": (d, l, reject) => {435 if (!Type.isNumber(d[0][0]))436 return reject;437 return d[0][0];438 } },439 {"name": "string_concat", "symbols": ["string", "_", {"literal":"+"}, "_", "string"], "postprocess": d => d[0] + d[4]},440 {"name": "boolean", "symbols": [{"literal":"not"}, "_", (lexer.has("space") ? {type: "space"} : space), "_", "condition"], "postprocess": d => !d[4]},441 {"name": "boolean", "symbols": ["is", "_", (lexer.has("space") ? {type: "space"} : space), "_", "condition"], "postprocess": d => d[4]},442 {"name": "boolean", "symbols": [{"literal":"!"}, "_", "boolean"], "postprocess": d => !d[2]},443 {"name": "boolean", "symbols": [{"literal":"!"}, "_", {"literal":"("}, "_", "boolean", "_", {"literal":")"}], "postprocess": d => !d[4]},444 {"name": "boolean", "symbols": [{"literal":"true"}], "postprocess": d => true},445 {"name": "boolean", "symbols": [{"literal":"false"}], "postprocess": d => false},446 {"name": "boolean", "symbols": [{"literal":"("}, "_", "boolean", "_", {"literal":")"}], "postprocess": d => d[2]},447 {"name": "boolean", "symbols": [{"literal":"("}, "_", "condition", "_", {"literal":")"}], "postprocess": d => d[2]},448 {"name": "boolean", "symbols": ["variable"], "postprocess": (d, l, reject) => {449 if (Type.isBoolean(d[0]))450 return d[0]451 return reject;452 } },453 {"name": "boolean", "symbols": ["function"], "postprocess": (d, l, reject) => {454 if (typeof d[0] !== 'boolean')455 return reject;456 return d[0]457 } },458 {"name": "myNull", "symbols": [{"literal":"null"}], "postprocess": d => null},459 {"name": "myNull", "symbols": [{"literal":"("}, "_", "myNull", "_", {"literal":")"}], "postprocess": d => d[2]},460 {"name": "myNull$subexpression$1", "symbols": ["objectItem"]},461 {"name": "myNull$subexpression$1", "symbols": ["arrayItem"]},462 {"name": "myNull$subexpression$1", "symbols": ["variable"]},463 {"name": "myNull$subexpression$1", "symbols": ["function"]},464 {"name": "myNull", "symbols": ["myNull$subexpression$1"], "postprocess": (d, l, reject) => {465 if (!Type.isNull(d[0][0]))466 return reject;467 return d[0][0];468 } },469 {"name": "object", "symbols": [{"literal":"{"}, "_", {"literal":"}"}], "postprocess": function(d) { return {}; }},470 {"name": "object$ebnf$1", "symbols": []},471 {"name": "object$ebnf$1$subexpression$1", "symbols": ["_", {"literal":","}, "_", "pair"]},472 {"name": "object$ebnf$1", "symbols": ["object$ebnf$1", "object$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},473 {"name": "object$ebnf$2$subexpression$1", "symbols": ["_", {"literal":","}]},474 {"name": "object$ebnf$2", "symbols": ["object$ebnf$2$subexpression$1"], "postprocess": id},475 {"name": "object$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},476 {"name": "object", "symbols": [{"literal":"{"}, "_", "pair", "object$ebnf$1", "object$ebnf$2", "_", {"literal":"}"}], "postprocess": extractObject},477 {"name": "object$subexpression$1", "symbols": ["objectItem"]},478 {"name": "object$subexpression$1", "symbols": ["arrayItem"]},479 {"name": "object$subexpression$1", "symbols": ["variable"]},480 {"name": "object$subexpression$1", "symbols": ["function"]},481 {"name": "object", "symbols": ["object$subexpression$1"], "postprocess": (d, l, reject) => {482 if (!Type.isObject(d[0][0]))483 return reject;484 return d[0][0];485 } },486 {"name": "objectItem", "symbols": ["object", "_", {"literal":"["}, "_", "string", "_", {"literal":"]"}], "postprocess": (d, l, reject) => {487 let f = d[0];488 let s = d[4];489 return getArrayItem(f[s]);490 }491 },492 {"name": "pair", "symbols": ["key", "_", {"literal":":"}, "_", "value"], "postprocess": d => [d[0], d[4]]},493 {"name": "key", "symbols": ["string"], "postprocess": id},494 {"name": "key", "symbols": ["property"], "postprocess": id},495 {"name": "property", "symbols": [(lexer.has("property") ? {type: "property"} : property)], "postprocess": d => d[0].value},496 {"name": "array", "symbols": [{"literal":"["}, "_", {"literal":"]"}], "postprocess": function(d) { return []; }},497 {"name": "array$ebnf$1", "symbols": []},498 {"name": "array$ebnf$1$subexpression$1", "symbols": ["_", {"literal":","}, "_", "value"]},499 {"name": "array$ebnf$1", "symbols": ["array$ebnf$1", "array$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},500 {"name": "array$ebnf$2$subexpression$1", "symbols": ["_", {"literal":","}]},501 {"name": "array$ebnf$2", "symbols": ["array$ebnf$2$subexpression$1"], "postprocess": id},502 {"name": "array$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},503 {"name": "array", "symbols": [{"literal":"["}, "_", "value", "array$ebnf$1", "array$ebnf$2", "_", {"literal":"]"}], "postprocess": extractArray},504 {"name": "array$subexpression$1", "symbols": ["objectItem"]},505 {"name": "array$subexpression$1", "symbols": ["arrayItem"]},506 {"name": "array$subexpression$1", "symbols": ["variable"]},507 {"name": "array$subexpression$1", "symbols": ["function"]},508 {"name": "array", "symbols": ["array$subexpression$1"], "postprocess": (d, l, reject) => {509 if (!Type.isArray(d[0][0]))510 return reject;511 return d[0][0];512 } },513 {"name": "arrayItem", "symbols": ["array", "_", {"literal":"["}, "_", "number", "_", {"literal":"]"}], "postprocess": (d, l, reject) => {514 let f = d[0];515 let s = d[4];516 return getArrayItem(f[s])517 }518 },519 {"name": "arrayItem", "symbols": ["array", "_", {"literal":"["}, "_", {"literal":"]"}], "postprocess": (d, l, reject) => {520 let f = d[0];521 let s = f.length-1;522 return getArrayItem(f[s])523 }524 },525 {"name": "function$subexpression$1$subexpression$1", "symbols": ["string"]},526 {"name": "function$subexpression$1$subexpression$1", "symbols": ["array"]},527 {"name": "function$subexpression$1$subexpression$1", "symbols": ["object"]},528 {"name": "function$subexpression$1", "symbols": ["function$subexpression$1$subexpression$1"], "postprocess": d => {529 let n = Object.values(d[0][0]);530 if (n === undefined) return null;531 return d[0][0];532 } },533 {"name": "function$ebnf$1$subexpression$1", "symbols": ["_", {"literal":"."}, "_", (lexer.has("functionName") ? {type: "functionName"} : functionName), "arguments"]},534 {"name": "function$ebnf$1", "symbols": ["function$ebnf$1$subexpression$1"]},535 {"name": "function$ebnf$1$subexpression$2", "symbols": ["_", {"literal":"."}, "_", (lexer.has("functionName") ? {type: "functionName"} : functionName), "arguments"]},536 {"name": "function$ebnf$1", "symbols": ["function$ebnf$1", "function$ebnf$1$subexpression$2"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},537 {"name": "function", "symbols": [{"literal":"for"}, "_", "function$subexpression$1", "_", {"literal":"=>"}, "function$ebnf$1"], "postprocess": d => {538 if (d[2] === null) throw 'Unexpected input in for loop.';539 let array = [];540 if (Type.isObject(d[2])) {541 array = {};542 }543 let keys = Object.keys(d[2])544 let values = Object.values(d[2])545 if (keys.length === 0) return d[2];546 for (let i = 0; i < keys.length; i++) {547 let value = functions[d[5][0][3].value](d[2][keys[i]], ...d[5][0][4]);548 for (let j = 1; j < d[5].length; j++) {549 let c = d[5][j];550 if (!functions[c[3].value]) {551 Type.Error('Function is not defined.');552 }553 value = functions[c[3]](554 value, ...c[4]555 );556 }557 558 if (Type.isObject(d[2])) {559 array[keys[i]] = value;560 }561 else array.push(value);562 }563 return array;564 } },565 {"name": "function", "symbols": [(lexer.has("functionName") ? {type: "functionName"} : functionName), "arguments"], "postprocess": d => {566 if (!functions[d[0]])567 Type.Error('Function is not defined.')568 return functions[d[0].value](...d[1]);569 } },570 {"name": "function$subexpression$2", "symbols": ["string"]},571 {"name": "function$subexpression$2", "symbols": ["number"]},572 {"name": "function$subexpression$2", "symbols": ["array"]},573 {"name": "function$subexpression$2", "symbols": ["object"]},574 {"name": "function", "symbols": ["function$subexpression$2", "_", {"literal":"=>"}, "_", (lexer.has("functionName") ? {type: "functionName"} : functionName), "arguments"], "postprocess": d => {575 if (!functions[d[4]])576 Type.Error('Function is not defined.')577 return functions[d[4].value](d[0][0], ...d[5]);578 } },579 {"name": "arguments", "symbols": [{"literal":"("}, "_", {"literal":")"}], "postprocess": d => []},580 {"name": "arguments$ebnf$1", "symbols": []},581 {"name": "arguments$ebnf$1$subexpression$1", "symbols": ["_", {"literal":","}, "_", "value"]},582 {"name": "arguments$ebnf$1", "symbols": ["arguments$ebnf$1", "arguments$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},583 {"name": "arguments$ebnf$2$subexpression$1", "symbols": ["_", {"literal":","}]},584 {"name": "arguments$ebnf$2", "symbols": ["arguments$ebnf$2$subexpression$1"], "postprocess": id},585 {"name": "arguments$ebnf$2", "symbols": [], "postprocess": function(d) {return null;}},586 {"name": "arguments", "symbols": [{"literal":"("}, "_", "value", "arguments$ebnf$1", "arguments$ebnf$2", "_", {"literal":")"}], "postprocess": d => extractArray(d)},587 {"name": "value", "symbols": [{"literal":"("}, "_", "value", "_", {"literal":")"}], "postprocess": d => d[2]},588 {"name": "value", "symbols": ["if"], "postprocess": id},589 {"name": "value", "symbols": ["html"], "postprocess": id},590 {"name": "value", "symbols": ["condition"], "postprocess": id},591 {"name": "value", "symbols": ["boolean"], "postprocess": id},592 {"name": "value", "symbols": ["object"], "postprocess": id},593 {"name": "value", "symbols": ["array"], "postprocess": id},594 {"name": "value", "symbols": ["import"], "postprocess": id},595 {"name": "value", "symbols": ["number"], "postprocess": id},596 {"name": "value", "symbols": ["hex"], "postprocess": id},597 {"name": "value", "symbols": ["string"], "postprocess": id},598 {"name": "value", "symbols": ["myNull"], "postprocess": d => null},599 {"name": "hex", "symbols": [(lexer.has("hexLong") ? {type: "hexLong"} : hexLong)], "postprocess": d => d[0].value},600 {"name": "hex", "symbols": [(lexer.has("hexShort") ? {type: "hexShort"} : hexShort)], "postprocess": d => d[0].value},601 {"name": "hex", "symbols": [{"literal":"("}, "_", "hex", "_", {"literal":")"}], "postprocess": d => d[2]},602 {"name": "hex", "symbols": ["variable"], "postprocess": (d, l, reject) => {603 if (Type.isHex(d[0]))604 return d[0]605 return reject;606 } },607 {"name": "hex", "symbols": ["function"], "postprocess": (d, l, reject) => {608 if (!Type.isHex(d[0]))609 return reject;610 return d[0];611 } },612 {"name": "string", "symbols": [(lexer.has("dstring") ? {type: "dstring"} : dstring)], "postprocess": d => d[0].value},613 {"name": "string", "symbols": [(lexer.has("sstring") ? {type: "sstring"} : sstring)], "postprocess": d => d[0].value},614 {"name": "string", "symbols": [(lexer.has("tstring") ? {type: "tstring"} : tstring)], "postprocess": d => d[0].value},615 {"name": "string", "symbols": ["hex"], "postprocess": id},616 {"name": "string$subexpression$1", "symbols": ["objectItem"]},617 {"name": "string$subexpression$1", "symbols": ["arrayItem"]},618 {"name": "string$subexpression$1", "symbols": ["variable"]},619 {"name": "string$subexpression$1", "symbols": ["function"]},620 {"name": "string", "symbols": ["string$subexpression$1"], "postprocess": (d, l, reject) => {621 if (!Type.isString(d[0][0]))622 return reject;623 return d[0][0];624 } },625 {"name": "string", "symbols": ["string_concat"], "postprocess": id},626 {"name": "string", "symbols": ["string", "_", {"literal":"["}, "_", "number", "_", {"literal":"]"}], "postprocess": (d, l, reject) => {627 let f = d[0];628 let s = d[4];629 return f[s];630 }631 },632 {"name": "string", "symbols": ["string", "_", {"literal":"["}, "_", {"literal":"]"}], "postprocess": (d, l, reject) => {633 let f = d[0];634 let s = f.length-1635 return f[s];636 } },637 {"name": "WS", "symbols": []},638 {"name": "WS", "symbols": [(lexer.has("space") ? {type: "space"} : space)], "postprocess": d => null},639 {"name": "_$ebnf$1", "symbols": []},640 {"name": "_$ebnf$1$subexpression$1", "symbols": ["WS", (lexer.has("comment") ? {type: "comment"} : comment)]},641 {"name": "_$ebnf$1", "symbols": ["_$ebnf$1", "_$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},642 {"name": "_", "symbols": ["_$ebnf$1", "WS"], "postprocess": d => {}},643 {"name": "semicolon", "symbols": [(lexer.has("semicolon") ? {type: "semicolon"} : semicolon)], "postprocess": d => d[0].value},644 {"name": "import", "symbols": [{"literal":"import"}, "_", "file"], "postprocess": function(d) {645 return d[2];646 } },647 {"name": "file", "symbols": ["string"], "postprocess": function(d, l, reject) {648 if (/​\.json$/​.test(d[0])) {649 let read = readFile(d[0])650 return JSON.parse(read.trim());651 }652 else {653 console.error(`[File Error]: "${d[0]}" is not found or is not json formated.`)654 return null655 }656 } }657]658 , ParserStart: "process"659}660if (typeof module !== 'undefined'&& typeof module.exports !== 'undefined') {661 module.exports = grammar;662} else {663 window.grammar = grammar;664}...

Full Screen

Full Screen

evaluate_models.py

Source:evaluate_models.py Github

copy

Full Screen

...92 carb_test_baseline_path, conj_mode=baseline_args.conj_mode)93 # carb test method1_ct_sup94 carb_test_postprocess_path = args.save_path + '/​carb_test_postprocess'95 os.makedirs(carb_test_postprocess_path, exist_ok=True)96 PostprocessHelper.postprocess(97 carb_test_baseline_path, carb_test_postprocess_path)98 # carb test method1_ct99 carb_test_postprocess_without_supplements_path = args.save_path + '/​carb_test_postprocess_without_supplements'100 os.makedirs(carb_test_postprocess_without_supplements_path, exist_ok=True)101 PostprocessHelper.postprocess(102 carb_test_baseline_path, carb_test_postprocess_without_supplements_path, use_supplements=False)103 # benchie baseline104 benchie_baseline_path = args.save_path + '/​benchie_baseline'105 baseline_args.test_data_path = args.test_data_benchie_path106 os.makedirs(benchie_baseline_path, exist_ok=True)107 extract(baseline_args, baseline_model, benchie_dataset,108 benchie_baseline_path, conj_mode=baseline_args.conj_mode)109 # benchie method1_ct_sup110 benchie_postprocess_path = args.save_path + '/​benchie_postprocess'111 os.makedirs(benchie_postprocess_path, exist_ok=True)112 PostprocessHelper.postprocess(113 benchie_baseline_path, benchie_postprocess_path)114 # benchie method1_ct115 benchie_postprocess_without_supplements_path = args.save_path + '/​benchie_postprocess_without_supplements'116 os.makedirs(benchie_postprocess_without_supplements_path, exist_ok=True)117 PostprocessHelper.postprocess(118 benchie_baseline_path, benchie_postprocess_without_supplements_path, use_supplements=False)119 # custom benchie baseline120 custom_benchie_baseline_path = args.save_path + '/​custom_benchie_baseline'121 baseline_args.test_data_path = args.test_data_custom_benchie_path122 os.makedirs(custom_benchie_baseline_path, exist_ok=True)123 extract(baseline_args, baseline_model, custom_benchie_dataset,124 custom_benchie_baseline_path, conj_mode=baseline_args.conj_mode)125 # custom benchie method1_ct_sup126 custom_benchie_postprocess_path = args.save_path + '/​custom_benchie_postprocess'127 os.makedirs(custom_benchie_postprocess_path, exist_ok=True)128 PostprocessHelper.postprocess(129 custom_benchie_baseline_path, custom_benchie_postprocess_path)130 # custom benchie method1_ct131 custom_benchie_postprocess_without_supplements_path = args.save_path + '/​custom_benchie_postprocess_without_supplements'132 os.makedirs(custom_benchie_postprocess_without_supplements_path, exist_ok=True)133 PostprocessHelper.postprocess(134 custom_benchie_baseline_path, custom_benchie_postprocess_without_supplements_path, use_supplements=False)135 # custom1 benchie baseline136 custom1_benchie_baseline_path = args.save_path + '/​custom1_benchie_baseline'137 baseline_args.test_data_path = args.test_data_custom_benchie_path138 os.makedirs(custom1_benchie_baseline_path, exist_ok=True)139 extract(baseline_args, baseline_model, custom_benchie_dataset,140 custom1_benchie_baseline_path, conj_mode=baseline_args.conj_mode)141 # custom1 benchie method1_ct_sup142 custom1_benchie_postprocess_path = args.save_path + '/​custom1_benchie_postprocess'143 os.makedirs(custom1_benchie_postprocess_path, exist_ok=True)144 PostprocessHelper.postprocess(145 custom1_benchie_baseline_path, custom1_benchie_postprocess_path)146 # custom1 benchie method1147 custom1_benchie_postprocess_without_supplements_path = args.save_path + '/​custom1_benchie_postprocess_without_supplements'148 os.makedirs(custom1_benchie_postprocess_without_supplements_path, exist_ok=True)149 PostprocessHelper.postprocess(150 custom1_benchie_baseline_path, custom1_benchie_postprocess_without_supplements_path, use_supplements=False)151 # custom2 benchie baseline152 custom2_benchie_baseline_path = args.save_path + '/​custom2_benchie_baseline'153 baseline_args.test_data_path = args.test_data_custom_benchie_path154 os.makedirs(custom2_benchie_baseline_path, exist_ok=True)155 extract(baseline_args, baseline_model, custom_benchie_dataset,156 custom2_benchie_baseline_path, conj_mode=baseline_args.conj_mode)157 # custom2 benchie method1_ct_sup158 custom2_benchie_postprocess_path = args.save_path + '/​custom2_benchie_postprocess'159 os.makedirs(custom2_benchie_postprocess_path, exist_ok=True)160 PostprocessHelper.postprocess(161 custom2_benchie_baseline_path, custom2_benchie_postprocess_path)162 # custom2 benchie method1163 custom2_benchie_postprocess_without_supplements_path = args.save_path + '/​custom2_benchie_postprocess_without_supplements'164 os.makedirs(custom2_benchie_postprocess_without_supplements_path, exist_ok=True)165 PostprocessHelper.postprocess(166 custom2_benchie_baseline_path, custom2_benchie_postprocess_without_supplements_path, use_supplements=False)167def extract_method2(args, method2_args, method2_model,168 carb_dataset, benchie_dataset, custom_benchie_dataset):169 # carb test method2170 carb_test_method2_path = args.save_path + '/​carb_test_method2'171 method2_args.test_data_path = args.test_data_carb_path172 extract(method2_args, method2_model, carb_dataset,173 carb_test_method2_path, conj_mode=method2_args.conj_mode)174 # benchie method2175 benchie_method2_path = args.save_path + '/​benchie_method2'176 method2_args.test_data_path = args.test_data_benchie_path177 os.makedirs(benchie_method2_path, exist_ok=True)178 extract(method2_args, method2_model, benchie_dataset,179 benchie_method2_path, conj_mode=method2_args.conj_mode)...

Full Screen

Full Screen

grammar.js

Source:grammar.js Github

copy

Full Screen

1/​/​ Generated automatically by nearley, version 2.20.12/​/​ http:/​/​github.com/​Hardmath123/​nearley3(function () {4 function id(x) {5 return x[0];6 }7 var grammar = {8 Lexer: undefined,9 ParserRules: [10 {11 name: 'program',12 symbols: ['functions'],13 postprocess: (data) => {14 return {15 functions: data[0],16 };17 },18 },19 {20 name: 'args',21 symbols: [{ literal: '(' }, 'expressions', { literal: ')' }],22 postprocess: (data) => {23 return data[1];24 },25 },26 {27 name: 'args',28 symbols: [{ literal: '(' }, { literal: ')' }],29 postprocess: (data) => {30 return [];31 },32 },33 {34 name: 'data_type$string$1',35 symbols: [36 { literal: 'i' },37 { literal: 'n' },38 { literal: 't' },39 { literal: '8' },40 ],41 postprocess: function joiner(d) {42 return d.join('');43 },44 },45 { name: 'data_type', symbols: ['data_type$string$1'], postprocess: id },46 {47 name: 'data_type$string$2',48 symbols: [49 { literal: 'i' },50 { literal: 'n' },51 { literal: 't' },52 { literal: '1' },53 { literal: '6' },54 ],55 postprocess: function joiner(d) {56 return d.join('');57 },58 },59 { name: 'data_type', symbols: ['data_type$string$2'], postprocess: id },60 {61 name: 'data_type$string$3',62 symbols: [63 { literal: 'i' },64 { literal: 'n' },65 { literal: 't' },66 { literal: '3' },67 { literal: '2' },68 ],69 postprocess: function joiner(d) {70 return d.join('');71 },72 },73 { name: 'data_type', symbols: ['data_type$string$3'], postprocess: id },74 {75 name: 'data_type$string$4',76 symbols: [{ literal: 'i' }, { literal: 'n' }, { literal: 't' }],77 postprocess: function joiner(d) {78 return d.join('');79 },80 },81 { name: 'data_type', symbols: ['data_type$string$4'], postprocess: id },82 {83 name: 'data_type$string$5',84 symbols: [85 { literal: 'i' },86 { literal: 'n' },87 { literal: 't' },88 { literal: '6' },89 { literal: '4' },90 ],91 postprocess: function joiner(d) {92 return d.join('');93 },94 },95 { name: 'data_type', symbols: ['data_type$string$5'], postprocess: id },96 {97 name: 'data_type$string$6',98 symbols: [99 { literal: 'u' },100 { literal: 'i' },101 { literal: 'n' },102 { literal: 't' },103 { literal: '8' },104 ],105 postprocess: function joiner(d) {106 return d.join('');107 },108 },109 { name: 'data_type', symbols: ['data_type$string$6'], postprocess: id },110 {111 name: 'data_type$string$7',112 symbols: [113 { literal: 'u' },114 { literal: 'i' },115 { literal: 'n' },116 { literal: 't' },117 { literal: '1' },118 { literal: '6' },119 ],120 postprocess: function joiner(d) {121 return d.join('');122 },123 },124 { name: 'data_type', symbols: ['data_type$string$7'], postprocess: id },125 {126 name: 'data_type$string$8',127 symbols: [128 { literal: 'u' },129 { literal: 'i' },130 { literal: 'n' },131 { literal: 't' },132 { literal: '3' },133 { literal: '2' },134 ],135 postprocess: function joiner(d) {136 return d.join('');137 },138 },139 { name: 'data_type', symbols: ['data_type$string$8'], postprocess: id },140 {141 name: 'data_type$string$9',142 symbols: [143 { literal: 'u' },144 { literal: 'i' },145 { literal: 'n' },146 { literal: 't' },147 ],148 postprocess: function joiner(d) {149 return d.join('');150 },151 },152 { name: 'data_type', symbols: ['data_type$string$9'], postprocess: id },153 {154 name: 'data_type$string$10',155 symbols: [156 { literal: 'u' },157 { literal: 'i' },158 { literal: 'n' },159 { literal: 't' },160 { literal: '6' },161 { literal: '4' },162 ],163 postprocess: function joiner(d) {164 return d.join('');165 },166 },167 { name: 'data_type', symbols: ['data_type$string$10'], postprocess: id },168 {169 name: 'data_type$string$11',170 symbols: [171 { literal: 'b' },172 { literal: 'o' },173 { literal: 'o' },174 { literal: 'l' },175 ],176 postprocess: function joiner(d) {177 return d.join('');178 },179 },180 { name: 'data_type', symbols: ['data_type$string$11'], postprocess: id },181 {182 name: 'data_type$string$12',183 symbols: [184 { literal: 's' },185 { literal: 't' },186 { literal: 'r' },187 { literal: 'i' },188 { literal: 'n' },189 { literal: 'g' },190 ],191 postprocess: function joiner(d) {192 return d.join('');193 },194 },195 { name: 'data_type', symbols: ['data_type$string$12'], postprocess: id },196 {197 name: 'data_type$string$13',198 symbols: [199 { literal: 'c' },200 { literal: 'h' },201 { literal: 'a' },202 { literal: 'r' },203 ],204 postprocess: function joiner(d) {205 return d.join('');206 },207 },208 { name: 'data_type', symbols: ['data_type$string$13'], postprocess: id },209 {210 name: 'expressions',211 symbols: ['___', 'expression', '___'],212 postprocess: (data) => [data[1]],213 },214 {215 name: 'expressions',216 symbols: ['___', 'expression', '___', { literal: ',' }, 'expressions'],217 postprocess: (data) => [data[1], ...data[4]],218 },219 {220 name: 'functions',221 symbols: ['___', 'function', '___'],222 postprocess: (data) => [data[1]],223 },224 {225 name: 'functions',226 symbols: ['___', 'function', '___', { literal: '\n' }, 'functions'],227 postprocess: (data) => [data[1], ...data[4]],228 },229 {230 name: 'function',231 symbols: ['identifier', '___', 'args', '___', 'block_statements'],232 postprocess: (data) => {233 return {234 type: 'function',235 return: 'int32',236 return_default: true,237 name: data[0],238 args: data[2],239 stmts: data[4],240 };241 },242 },243 {244 name: 'function',245 symbols: [246 'data_type',247 '___',248 'identifier',249 '___',250 'args',251 '___',252 'block_statements',253 ],254 postprocess: (data) => {255 return {256 type: 'function',257 return: data[0],258 name: data[2],259 args: data[4],260 stmts: data[6],261 };262 },263 },264 {265 name: 'function',266 symbols: ['data_type', '___', 'identifier', '___', 'block_statements'],267 postprocess: (data) => {268 return {269 type: 'function',270 return: data[0],271 name: data[2],272 args: [],273 stmts: data[4],274 };275 },276 },277 {278 name: 'function',279 symbols: ['identifier', '___', 'block_statements'],280 postprocess: (data) => {281 return {282 type: 'function',283 return: 'int32',284 return_default: true,285 name: data[0],286 args: [],287 stmts: data[2],288 };289 },290 },291 {292 name: 'block_statements',293 symbols: [{ literal: '{' }, 'statements', { literal: '}' }],294 postprocess: (data) => {295 return data[1];296 },297 },298 {299 name: 'block_statements',300 symbols: [{ literal: '{' }, '___', { literal: '}' }],301 postprocess: (data) => {302 return [];303 },304 },305 {306 name: 'statements',307 symbols: ['___', 'statement', '___'],308 postprocess: (data) => [data[1]],309 },310 {311 name: 'statements',312 symbols: ['___', 'statement', '___', { literal: '\n' }, 'statements'],313 postprocess: (data) => [data[1], ...data[4]],314 },315 { name: 'statement', symbols: ['var_assignment'], postprocess: id },316 { name: 'statement', symbols: ['print_statement'], postprocess: id },317 { name: 'statement', symbols: ['while_loop'], postprocess: id },318 {319 name: 'while_loop$string$1',320 symbols: [321 { literal: 'w' },322 { literal: 'h' },323 { literal: 'i' },324 { literal: 'l' },325 { literal: 'e' },326 ],327 postprocess: function joiner(d) {328 return d.join('');329 },330 },331 {332 name: 'while_loop',333 symbols: [334 'while_loop$string$1',335 '__',336 'binary_expression',337 '__',338 { literal: '{' },339 '_',340 { literal: '\n' },341 'statements',342 { literal: '\n' },343 { literal: '}' },344 ],345 postprocess: (data) => {346 return {347 type: 'while_loop',348 condition: data[2],349 body: data[7],350 };351 },352 },353 {354 name: 'print_statement$string$1',355 symbols: [356 { literal: 'p' },357 { literal: 'r' },358 { literal: 'i' },359 { literal: 'n' },360 { literal: 't' },361 ],362 postprocess: function joiner(d) {363 return d.join('');364 },365 },366 {367 name: 'print_statement',368 symbols: ['print_statement$string$1', '__', 'expression'],369 postprocess: (data) => {370 return {371 type: 'print_statement',372 expression: data[2],373 };374 },375 },376 { name: 'expression', symbols: ['unary_expression'], postprocess: id },377 { name: 'expression', symbols: ['binary_expression'], postprocess: id },378 { name: 'unary_expression', symbols: ['number'], postprocess: id },379 { name: 'unary_expression', symbols: ['identifier'], postprocess: id },380 { name: 'operator', symbols: [{ literal: '+' }], postprocess: id },381 { name: 'operator', symbols: [{ literal: '-' }], postprocess: id },382 { name: 'operator', symbols: [{ literal: '*' }], postprocess: id },383 { name: 'operator', symbols: [{ literal: '/​' }], postprocess: id },384 {385 name: 'operator$string$1',386 symbols: [{ literal: '>' }, { literal: '=' }],387 postprocess: function joiner(d) {388 return d.join('');389 },390 },391 { name: 'operator', symbols: ['operator$string$1'], postprocess: id },392 {393 name: 'operator$string$2',394 symbols: [{ literal: '<' }, { literal: '=' }],395 postprocess: function joiner(d) {396 return d.join('');397 },398 },399 { name: 'operator', symbols: ['operator$string$2'], postprocess: id },400 { name: 'operator', symbols: [{ literal: '>' }], postprocess: id },401 { name: 'operator', symbols: [{ literal: '<' }], postprocess: id },402 { name: 'operator', symbols: [{ literal: '=' }], postprocess: id },403 {404 name: 'binary_expression',405 symbols: ['unary_expression', '_', 'operator', '_', 'expression'],406 postprocess: (data) => {407 return {408 type: 'binary_expression',409 left: data[0],410 operator: data[2],411 right: data[4],412 };413 },414 },415 {416 name: 'var_assignment$string$1',417 symbols: [{ literal: ':' }, { literal: '=' }],418 postprocess: function joiner(d) {419 return d.join('');420 },421 },422 {423 name: 'var_assignment',424 symbols: [425 'identifier',426 '_',427 'var_assignment$string$1',428 '_',429 'expression',430 ],431 postprocess: (data) => {432 return {433 type: 'var_assignment',434 varname: data[0],435 value: data[4],436 };437 },438 },439 { name: 'identifier$ebnf$1', symbols: [/​[a-z]/​] },440 {441 name: 'identifier$ebnf$1',442 symbols: ['identifier$ebnf$1', /​[a-z]/​],443 postprocess: function arrpush(d) {444 return d[0].concat([d[1]]);445 },446 },447 {448 name: 'identifier',449 symbols: ['identifier$ebnf$1'],450 postprocess: (data) => data[0].join(''),451 },452 {453 name: 'number',454 symbols: ['digits', { literal: '.' }, 'digits'],455 postprocess: (data) => Number(data[0] + '.' + data[2]),456 },457 {458 name: 'number',459 symbols: ['digits'],460 postprocess: (data) => Number(data[0]),461 },462 { name: 'digits$ebnf$1', symbols: [/​[0-9]/​] },463 {464 name: 'digits$ebnf$1',465 symbols: ['digits$ebnf$1', /​[0-9]/​],466 postprocess: function arrpush(d) {467 return d[0].concat([d[1]]);468 },469 },470 {471 name: 'digits',472 symbols: ['digits$ebnf$1'],473 postprocess: (data) => data[0].join(''),474 },475 { name: '_$ebnf$1', symbols: [] },476 {477 name: '_$ebnf$1',478 symbols: ['_$ebnf$1', /​[ \t]/​],479 postprocess: function arrpush(d) {480 return d[0].concat([d[1]]);481 },482 },483 { name: '_', symbols: ['_$ebnf$1'] },484 { name: '__$ebnf$1', symbols: [/​[ \t]/​] },485 {486 name: '__$ebnf$1',487 symbols: ['__$ebnf$1', /​[ \t]/​],488 postprocess: function arrpush(d) {489 return d[0].concat([d[1]]);490 },491 },492 { name: '__', symbols: ['__$ebnf$1'] },493 { name: '___$ebnf$1', symbols: [] },494 {495 name: '___$ebnf$1',496 symbols: ['___$ebnf$1', /​[ \t\n]/​],497 postprocess: function arrpush(d) {498 return d[0].concat([d[1]]);499 },500 },501 { name: '___', symbols: ['___$ebnf$1'] },502 ],503 ParserStart: 'program',504 };505 if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {506 module.exports = grammar;507 } else {508 window.grammar = grammar;509 }...

Full Screen

Full Screen

test_polyoptions.py

Source:test_polyoptions.py Github

copy

Full Screen

...26 assert Expand.preprocess(True) is True27 assert Expand.preprocess(0) is False28 assert Expand.preprocess(1) is True29 raises(OptionError, lambda: Expand.preprocess(x))30def test_Expand_postprocess():31 opt = {'expand': True}32 Expand.postprocess(opt)33 assert opt == {'expand': True}34def test_Gens_preprocess():35 assert Gens.preprocess((None,)) == ()36 assert Gens.preprocess((x, y, z)) == (x, y, z)37 assert Gens.preprocess(((x, y, z),)) == (x, y, z)38 a = Symbol('a', commutative=False)39 raises(GeneratorsError, lambda: Gens.preprocess((x, x, y)))40 raises(GeneratorsError, lambda: Gens.preprocess((x, y, a)))41def test_Gens_postprocess():42 opt = {'gens': (x, y)}43 Gens.postprocess(opt)44 assert opt == {'gens': (x, y)}45def test_Wrt_preprocess():46 assert Wrt.preprocess(x) == ['x']47 assert Wrt.preprocess('') == []48 assert Wrt.preprocess(' ') == []49 assert Wrt.preprocess('x,y') == ['x', 'y']50 assert Wrt.preprocess('x y') == ['x', 'y']51 assert Wrt.preprocess('x, y') == ['x', 'y']52 assert Wrt.preprocess('x , y') == ['x', 'y']53 assert Wrt.preprocess(' x, y') == ['x', 'y']54 assert Wrt.preprocess(' x, y') == ['x', 'y']55 assert Wrt.preprocess([x, y]) == ['x', 'y']56 raises(OptionError, lambda: Wrt.preprocess(','))57 raises(OptionError, lambda: Wrt.preprocess(0))58def test_Wrt_postprocess():59 opt = {'wrt': ['x']}60 Wrt.postprocess(opt)61 assert opt == {'wrt': ['x']}62def test_Sort_preprocess():63 assert Sort.preprocess([x, y, z]) == ['x', 'y', 'z']64 assert Sort.preprocess((x, y, z)) == ['x', 'y', 'z']65 assert Sort.preprocess('x > y > z') == ['x', 'y', 'z']66 assert Sort.preprocess('x>y>z') == ['x', 'y', 'z']67 raises(OptionError, lambda: Sort.preprocess(0))68 raises(OptionError, lambda: Sort.preprocess(set([x, y, z])))69def test_Sort_postprocess():70 opt = {'sort': 'x > y'}71 Sort.postprocess(opt)72 assert opt == {'sort': 'x > y'}73def test_Order_preprocess():74 assert Order.preprocess('lex') == lex75def test_Order_postprocess():76 opt = {'order': True}77 Order.postprocess(opt)78 assert opt == {'order': True}79def test_Field_preprocess():80 assert Field.preprocess(False) is False81 assert Field.preprocess(True) is True82 assert Field.preprocess(0) is False83 assert Field.preprocess(1) is True84 raises(OptionError, lambda: Field.preprocess(x))85def test_Field_postprocess():86 opt = {'field': True}87 Field.postprocess(opt)88 assert opt == {'field': True}89def test_Greedy_preprocess():90 assert Greedy.preprocess(False) is False91 assert Greedy.preprocess(True) is True92 assert Greedy.preprocess(0) is False93 assert Greedy.preprocess(1) is True94 raises(OptionError, lambda: Greedy.preprocess(x))95def test_Greedy_postprocess():96 opt = {'greedy': True}97 Greedy.postprocess(opt)98 assert opt == {'greedy': True}99def test_Domain_preprocess():100 assert Domain.preprocess(ZZ) == ZZ101 assert Domain.preprocess(QQ) == QQ102 assert Domain.preprocess(EX) == EX103 assert Domain.preprocess(FF(2)) == FF(2)104 assert Domain.preprocess(ZZ[x, y]) == ZZ[x, y]105 assert Domain.preprocess('Z') == ZZ106 assert Domain.preprocess('Q') == QQ107 assert Domain.preprocess('ZZ') == ZZ108 assert Domain.preprocess('QQ') == QQ109 assert Domain.preprocess('EX') == EX110 assert Domain.preprocess('FF(23)') == FF(23)111 assert Domain.preprocess('GF(23)') == GF(23)112 raises(OptionError, lambda: Domain.preprocess('Z[]'))113 assert Domain.preprocess('Z[x]') == ZZ[x]114 assert Domain.preprocess('Q[x]') == QQ[x]115 assert Domain.preprocess('ZZ[x]') == ZZ[x]116 assert Domain.preprocess('QQ[x]') == QQ[x]117 assert Domain.preprocess('Z[x,y]') == ZZ[x, y]118 assert Domain.preprocess('Q[x,y]') == QQ[x, y]119 assert Domain.preprocess('ZZ[x,y]') == ZZ[x, y]120 assert Domain.preprocess('QQ[x,y]') == QQ[x, y]121 raises(OptionError, lambda: Domain.preprocess('Z()'))122 assert Domain.preprocess('Z(x)') == ZZ.frac_field(x)123 assert Domain.preprocess('Q(x)') == QQ.frac_field(x)124 assert Domain.preprocess('ZZ(x)') == ZZ.frac_field(x)125 assert Domain.preprocess('QQ(x)') == QQ.frac_field(x)126 assert Domain.preprocess('Z(x,y)') == ZZ.frac_field(x, y)127 assert Domain.preprocess('Q(x,y)') == QQ.frac_field(x, y)128 assert Domain.preprocess('ZZ(x,y)') == ZZ.frac_field(x, y)129 assert Domain.preprocess('QQ(x,y)') == QQ.frac_field(x, y)130 assert Domain.preprocess('Q<I>') == QQ.algebraic_field(I)131 assert Domain.preprocess('QQ<I>') == QQ.algebraic_field(I)132 assert Domain.preprocess('Q<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)133 assert Domain.preprocess(134 'QQ<sqrt(2), I>') == QQ.algebraic_field(sqrt(2), I)135 raises(OptionError, lambda: Domain.preprocess('abc'))136def test_Domain_postprocess():137 raises(GeneratorsError, lambda: Domain.postprocess({'gens': (x, y),138 'domain': ZZ[y, z]}))139 raises(GeneratorsError, lambda: Domain.postprocess({'gens': (),140 'domain': EX}))141 raises(GeneratorsError, lambda: Domain.postprocess({'domain': EX}))142def test_Split_preprocess():143 assert Split.preprocess(False) is False144 assert Split.preprocess(True) is True145 assert Split.preprocess(0) is False146 assert Split.preprocess(1) is True147 raises(OptionError, lambda: Split.preprocess(x))148def test_Split_postprocess():149 raises(NotImplementedError, lambda: Split.postprocess({'split': True}))150def test_Gaussian_preprocess():151 assert Gaussian.preprocess(False) is False152 assert Gaussian.preprocess(True) is True153 assert Gaussian.preprocess(0) is False154 assert Gaussian.preprocess(1) is True155 raises(OptionError, lambda: Gaussian.preprocess(x))156def test_Gaussian_postprocess():157 opt = {'gaussian': True}158 Gaussian.postprocess(opt)159 assert opt == {160 'gaussian': True,161 'extension': set([I]),162 'domain': QQ.algebraic_field(I),163 }164def test_Extension_preprocess():165 assert Extension.preprocess(True) is True166 assert Extension.preprocess(1) is True167 assert Extension.preprocess([]) is None168 assert Extension.preprocess(sqrt(2)) == set([sqrt(2)])169 assert Extension.preprocess([sqrt(2)]) == set([sqrt(2)])170 assert Extension.preprocess([sqrt(2), I]) == set([sqrt(2), I])171 raises(OptionError, lambda: Extension.preprocess(False))172 raises(OptionError, lambda: Extension.preprocess(0))173def test_Extension_postprocess():174 opt = {'extension': set([sqrt(2)])}175 Extension.postprocess(opt)176 assert opt == {177 'extension': set([sqrt(2)]),178 'domain': QQ.algebraic_field(sqrt(2)),179 }180 opt = {'extension': True}181 Extension.postprocess(opt)182 assert opt == {'extension': True}183def test_Modulus_preprocess():184 assert Modulus.preprocess(23) == 23185 assert Modulus.preprocess(Integer(23)) == 23186 raises(OptionError, lambda: Modulus.preprocess(0))187 raises(OptionError, lambda: Modulus.preprocess(x))188def test_Modulus_postprocess():189 opt = {'modulus': 5}190 Modulus.postprocess(opt)191 assert opt == {192 'modulus': 5,193 'domain': FF(5),194 }195 opt = {'modulus': 5, 'symmetric': False}196 Modulus.postprocess(opt)197 assert opt == {198 'modulus': 5,199 'domain': FF(5, False),200 'symmetric': False,201 }202def test_Symmetric_preprocess():203 assert Symmetric.preprocess(False) is False204 assert Symmetric.preprocess(True) is True205 assert Symmetric.preprocess(0) is False206 assert Symmetric.preprocess(1) is True207 raises(OptionError, lambda: Symmetric.preprocess(x))208def test_Symmetric_postprocess():209 opt = {'symmetric': True}210 Symmetric.postprocess(opt)211 assert opt == {'symmetric': True}212def test_Strict_preprocess():213 assert Strict.preprocess(False) is False214 assert Strict.preprocess(True) is True215 assert Strict.preprocess(0) is False216 assert Strict.preprocess(1) is True217 raises(OptionError, lambda: Strict.preprocess(x))218def test_Strict_postprocess():219 opt = {'strict': True}220 Strict.postprocess(opt)221 assert opt == {'strict': True}222def test_Auto_preprocess():223 assert Auto.preprocess(False) is False224 assert Auto.preprocess(True) is True225 assert Auto.preprocess(0) is False226 assert Auto.preprocess(1) is True227 raises(OptionError, lambda: Auto.preprocess(x))228def test_Auto_postprocess():229 opt = {'auto': True}230 Auto.postprocess(opt)231 assert opt == {'auto': True}232def test_Frac_preprocess():233 assert Frac.preprocess(False) is False234 assert Frac.preprocess(True) is True235 assert Frac.preprocess(0) is False236 assert Frac.preprocess(1) is True237 raises(OptionError, lambda: Frac.preprocess(x))238def test_Frac_postprocess():239 opt = {'frac': True}240 Frac.postprocess(opt)241 assert opt == {'frac': True}242def test_Formal_preprocess():243 assert Formal.preprocess(False) is False244 assert Formal.preprocess(True) is True245 assert Formal.preprocess(0) is False246 assert Formal.preprocess(1) is True247 raises(OptionError, lambda: Formal.preprocess(x))248def test_Formal_postprocess():249 opt = {'formal': True}250 Formal.postprocess(opt)251 assert opt == {'formal': True}252def test_Polys_preprocess():253 assert Polys.preprocess(False) is False254 assert Polys.preprocess(True) is True255 assert Polys.preprocess(0) is False256 assert Polys.preprocess(1) is True257 raises(OptionError, lambda: Polys.preprocess(x))258def test_Polys_postprocess():259 opt = {'polys': True}260 Polys.postprocess(opt)261 assert opt == {'polys': True}262def test_Include_preprocess():263 assert Include.preprocess(False) is False264 assert Include.preprocess(True) is True265 assert Include.preprocess(0) is False266 assert Include.preprocess(1) is True267 raises(OptionError, lambda: Include.preprocess(x))268def test_Include_postprocess():269 opt = {'include': True}270 Include.postprocess(opt)271 assert opt == {'include': True}272def test_All_preprocess():273 assert All.preprocess(False) is False274 assert All.preprocess(True) is True275 assert All.preprocess(0) is False276 assert All.preprocess(1) is True277 raises(OptionError, lambda: All.preprocess(x))278def test_All_postprocess():279 opt = {'all': True}280 All.postprocess(opt)281 assert opt == {'all': True}282def test_Gen_postprocess():283 opt = {'gen': x}284 Gen.postprocess(opt)285 assert opt == {'gen': x}286def test_Symbols_preprocess():287 raises(OptionError, lambda: Symbols.preprocess(x))288def test_Symbols_postprocess():289 opt = {'symbols': [x, y, z]}290 Symbols.postprocess(opt)291 assert opt == {'symbols': [x, y, z]}292def test_Method_preprocess():293 raises(OptionError, lambda: Method.preprocess(10))294def test_Method_postprocess():295 opt = {'method': 'f5b'}296 Method.postprocess(opt)...

Full Screen

Full Screen

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run autotest automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

... View sample repo... View DocumentationSign up Free
›
_

Try LambdaTest Now !!

Get 100 minutes of automation test minutes FREE!!

...
Sign up with GoogleSign up with Email
Next-Gen App & Browser Testing Cloud

Was this article helpful?

Helpful

NotHelpful