KaneAI - World’s First E2E Software Testing Agent.Book a Demo 
How to use collectRules method in avocado
Best Python code snippet using avocado_python
spark.py
Source:spark.py 
...50 def __init__(self, start):51 self.rules = {}52 self.rule2func = {}53 self.rule2name = {}54 self.collectRules()55 self.augment(start)56 self.ruleschanged = 157 _NULLABLE = '\e_'58 _START = 'START'59 _BOF = '|-'60 #61 # When pickling, take the time to generate the full state machine;62 # some information is then extraneous, too. Unfortunately we63 # can't save the rule2func map.64 #65 def __getstate__(self):66 if self.ruleschanged:67 #68 # XXX - duplicated from parse()69 #70 self.computeNull()71 self.newrules = {}72 self.new2old = {}73 self.makeNewRules()74 self.ruleschanged = 075 self.edges, self.cores = {}, {}76 self.states = { 0: self.makeState0() }77 self.makeState(0, self._BOF)78 #79 # XXX - should find a better way to do this..80 #81 changes = 182 while changes:83 changes = 084 for k, v in self.edges.items():85 if v is None:86 state, sym = k87 if self.states.has_key(state):88 self.goto(state, sym)89 changes = 190 rv = self.__dict__.copy()91 for s in self.states.values():92 del s.items93 del rv['rule2func']94 del rv['nullable']95 del rv['cores']96 return rv97 def __setstate__(self, D):98 self.rules = {}99 self.rule2func = {}100 self.rule2name = {}101 self.collectRules()102 start = D['rules'][self._START][0][1][1] # Blech.103 self.augment(start)104 D['rule2func'] = self.rule2func105 D['makeSet'] = self.makeSet_fast106 self.__dict__ = D107 #108 # A hook for GenericASTBuilder and GenericASTMatcher. Mess109 # thee not with this; nor shall thee toucheth the _preprocess110 # argument to addRule.111 #112 def preprocess(self, rule, func): return rule, func113 def addRule(self, doc, func, _preprocess=1):114 fn = func115 rules = doc.split()116 index = []117 for i in xrange(len(rules)):118 if rules[i] == '::=':119 index.append(i-1)120 index.append(len(rules))121 for i in xrange(len(index)-1):122 lhs = rules[index[i]]123 rhs = rules[index[i]+2:index[i+1]]124 rule = (lhs, tuple(rhs))125 if _preprocess:126 rule, fn = self.preprocess(rule, func)127 if self.rules.has_key(lhs):128 self.rules[lhs].append(rule)129 else:130 self.rules[lhs] = [ rule ]131 self.rule2func[rule] = fn132 self.rule2name[rule] = func.__name__[2:]133 self.ruleschanged = 1134 def collectRules(self):135 for name in _namelist(self):136 if name[:2] == 'p_':137 func = getattr(self, name)138 doc = func.__doc__139 self.addRule(doc, func)140 def augment(self, start):141 rule = '%s ::= %s %s' % (self._START, self._BOF, start)142 self.addRule(rule, lambda args: args[1], 0)143 def computeNull(self):144 self.nullable = {}145 tbd = []146 for rulelist in self.rules.values():147 lhs = rulelist[0][0]148 self.nullable[lhs] = 0149 for rule in rulelist:150 rhs = rule[1]151 if len(rhs) == 0:152 self.nullable[lhs] = 1153 continue154 #155 # We only need to consider rules which156 # consist entirely of nonterminal symbols.157 # This should be a savings on typical158 # grammars.159 #160 for sym in rhs:161 if not self.rules.has_key(sym):162 break163 else:164 tbd.append(rule)165 changes = 1166 while changes:167 changes = 0168 for lhs, rhs in tbd:169 if self.nullable[lhs]:170 continue171 for sym in rhs:172 if not self.nullable[sym]:173 break174 else:175 self.nullable[lhs] = 1176 changes = 1177 def makeState0(self):178 s0 = _State(0, [])179 for rule in self.newrules[self._START]:180 s0.items.append((rule, 0))181 return s0182 def finalState(self, tokens):183 #184 # Yuck.185 #186 if len(self.newrules[self._START]) == 2 and len(tokens) == 0:187 return 1188 start = self.rules[self._START][0][1][1]189 return self.goto(1, start)190 def makeNewRules(self):191 worklist = []192 for rulelist in self.rules.values():193 for rule in rulelist:194 worklist.append((rule, 0, 1, rule))195 for rule, i, candidate, oldrule in worklist:196 lhs, rhs = rule197 n = len(rhs)198 while i < n:199 sym = rhs[i]200 if not self.rules.has_key(sym) or \201 not self.nullable[sym]:202 candidate = 0203 i = i + 1204 continue205 newrhs = list(rhs)206 newrhs[i] = self._NULLABLE+sym207 newrule = (lhs, tuple(newrhs))208 worklist.append((newrule, i+1,209 candidate, oldrule))210 candidate = 0211 i = i + 1212 else:213 if candidate:214 lhs = self._NULLABLE+lhs215 rule = (lhs, rhs)216 if self.newrules.has_key(lhs):217 self.newrules[lhs].append(rule)218 else:219 self.newrules[lhs] = [ rule ]220 self.new2old[rule] = oldrule221 def typestring(self, token):222 return None223 def error(self, token):224 print "Syntax error at or near `%s' token" % token225 raise SystemExit226 def parse(self, tokens):227 sets = [ [(1,0), (2,0)] ]228 self.links = {}229 if self.ruleschanged:230 self.computeNull()231 self.newrules = {}232 self.new2old = {}233 self.makeNewRules()234 self.ruleschanged = 0235 self.edges, self.cores = {}, {}236 self.states = { 0: self.makeState0() }237 self.makeState(0, self._BOF)238 for i in xrange(len(tokens)):239 sets.append([])240 if sets[i] == []:241 break 242 self.makeSet(tokens[i], sets, i)243 else:244 sets.append([])245 self.makeSet(None, sets, len(tokens))246 finalitem = (self.finalState(tokens), 0)247 if finalitem not in sets[-2]:248 if len(tokens) > 0:249 self.error(tokens[i-1])250 else:251 self.error(None)252 return self.buildTree(self._START, finalitem,253 tokens, len(sets)-2)254 def isnullable(self, sym):255 #256 # For symbols in G_e only. If we weren't supporting 1.5,257 # could just use sym.startswith().258 #259 return self._NULLABLE == sym[0:len(self._NULLABLE)]260 def skip(self, (lhs, rhs), pos=0):261 n = len(rhs)262 while pos < n:263 if not self.isnullable(rhs[pos]):264 break265 pos = pos + 1266 return pos267 def makeState(self, state, sym):268 assert sym is not None269 #270 # Compute \epsilon-kernel state's core and see if271 # it exists already.272 #273 kitems = []274 for rule, pos in self.states[state].items:275 lhs, rhs = rule276 if rhs[pos:pos+1] == (sym,):277 kitems.append((rule, self.skip(rule, pos+1)))278 tcore = tuple(sorted(kitems))279 if self.cores.has_key(tcore):280 return self.cores[tcore]281 #282 # Nope, doesn't exist. Compute it and the associated283 # \epsilon-nonkernel state together; we'll need it right away.284 #285 k = self.cores[tcore] = len(self.states)286 K, NK = _State(k, kitems), _State(k+1, [])287 self.states[k] = K288 predicted = {}289 edges = self.edges290 rules = self.newrules291 for X in K, NK:292 worklist = X.items293 for item in worklist:294 rule, pos = item295 lhs, rhs = rule296 if pos == len(rhs):297 X.complete.append(rule)298 continue299 nextSym = rhs[pos]300 key = (X.stateno, nextSym)301 if not rules.has_key(nextSym):302 if not edges.has_key(key):303 edges[key] = None304 X.T.append(nextSym)305 else:306 edges[key] = None307 if not predicted.has_key(nextSym):308 predicted[nextSym] = 1309 for prule in rules[nextSym]:310 ppos = self.skip(prule)311 new = (prule, ppos)312 NK.items.append(new)313 #314 # Problem: we know K needs generating, but we315 # don't yet know about NK. Can't commit anything316 # regarding NK to self.edges until we're sure. Should317 # we delay committing on both K and NK to avoid this318 # hacky code? This creates other problems..319 #320 if X is K:321 edges = {}322 if NK.items == []:323 return k324 #325 # Check for \epsilon-nonkernel's core. Unfortunately we326 # need to know the entire set of predicted nonterminals327 # to do this without accidentally duplicating states.328 #329 tcore = tuple(sorted(predicted.keys()))330 if self.cores.has_key(tcore):331 self.edges[(k, None)] = self.cores[tcore]332 return k333 nk = self.cores[tcore] = self.edges[(k, None)] = NK.stateno334 self.edges.update(edges)335 self.states[nk] = NK336 return k337 def goto(self, state, sym):338 key = (state, sym)339 if not self.edges.has_key(key):340 #341 # No transitions from state on sym.342 #343 return None344 rv = self.edges[key]345 if rv is None:346 #347 # Target state isn't generated yet. Remedy this.348 #349 rv = self.makeState(state, sym)350 self.edges[key] = rv351 return rv352 def gotoT(self, state, t):353 return [self.goto(state, t)]354 def gotoST(self, state, st):355 rv = []356 for t in self.states[state].T:357 if st == t:358 rv.append(self.goto(state, t))359 return rv360 def add(self, set, item, i=None, predecessor=None, causal=None):361 if predecessor is None:362 if item not in set:363 set.append(item)364 else:365 key = (item, i)366 if item not in set:367 self.links[key] = []368 set.append(item)369 self.links[key].append((predecessor, causal))370 def makeSet(self, token, sets, i):371 cur, next = sets[i], sets[i+1]372 ttype = token is not None and self.typestring(token) or None373 if ttype is not None:374 fn, arg = self.gotoT, ttype375 else:376 fn, arg = self.gotoST, token377 for item in cur:378 ptr = (item, i)379 state, parent = item380 add = fn(state, arg)381 for k in add:382 if k is not None:383 self.add(next, (k, parent), i+1, ptr)384 nk = self.goto(k, None)385 if nk is not None:386 self.add(next, (nk, i+1))387 if parent == i:388 continue389 for rule in self.states[state].complete:390 lhs, rhs = rule391 for pitem in sets[parent]:392 pstate, pparent = pitem393 k = self.goto(pstate, lhs)394 if k is not None:395 why = (item, i, rule)396 pptr = (pitem, parent)397 self.add(cur, (k, pparent),398 i, pptr, why)399 nk = self.goto(k, None)400 if nk is not None:401 self.add(cur, (nk, i))402 def makeSet_fast(self, token, sets, i):403 #404 # Call *only* when the entire state machine has been built!405 # It relies on self.edges being filled in completely, and406 # then duplicates and inlines code to boost speed at the407 # cost of extreme ugliness.408 #409 cur, next = sets[i], sets[i+1]410 ttype = token is not None and self.typestring(token) or None411 for item in cur:412 ptr = (item, i)413 state, parent = item414 if ttype is not None:415 k = self.edges.get((state, ttype), None)416 if k is not None:417 #self.add(next, (k, parent), i+1, ptr)418 #INLINED --v419 new = (k, parent)420 key = (new, i+1)421 if new not in next:422 self.links[key] = []423 next.append(new)424 self.links[key].append((ptr, None))425 #INLINED --^426 #nk = self.goto(k, None)427 nk = self.edges.get((k, None), None)428 if nk is not None:429 #self.add(next, (nk, i+1))430 #INLINED --v431 new = (nk, i+1)432 if new not in next:433 next.append(new)434 #INLINED --^435 else:436 add = self.gotoST(state, token)437 for k in add:438 if k is not None:439 self.add(next, (k, parent), i+1, ptr)440 #nk = self.goto(k, None)441 nk = self.edges.get((k, None), None)442 if nk is not None:443 self.add(next, (nk, i+1))444 if parent == i:445 continue446 for rule in self.states[state].complete:447 lhs, rhs = rule448 for pitem in sets[parent]:449 pstate, pparent = pitem450 #k = self.goto(pstate, lhs)451 k = self.edges.get((pstate, lhs), None)452 if k is not None:453 why = (item, i, rule)454 pptr = (pitem, parent)455 #self.add(cur, (k, pparent),456 # i, pptr, why)457 #INLINED --v458 new = (k, pparent)459 key = (new, i)460 if new not in cur:461 self.links[key] = []462 cur.append(new)463 self.links[key].append((pptr, why))464 #INLINED --^465 #nk = self.goto(k, None)466 nk = self.edges.get((k, None), None)467 if nk is not None:468 #self.add(cur, (nk, i))469 #INLINED --v470 new = (nk, i)471 if new not in cur:472 cur.append(new)473 #INLINED --^474 def predecessor(self, key, causal):475 for p, c in self.links[key]:476 if c == causal:477 return p478 assert 0479 def causal(self, key):480 links = self.links[key]481 if len(links) == 1:482 return links[0][1]483 choices = []484 rule2cause = {}485 for p, c in links:486 rule = c[2]487 choices.append(rule)488 rule2cause[rule] = c489 return rule2cause[self.ambiguity(choices)]490 def deriveEpsilon(self, nt):491 if len(self.newrules[nt]) > 1:492 rule = self.ambiguity(self.newrules[nt])493 else:494 rule = self.newrules[nt][0]495 #print rule496 rhs = rule[1]497 attr = [None] * len(rhs)498 for i in xrange(len(rhs)-1, -1, -1):499 attr[i] = self.deriveEpsilon(rhs[i])500 return self.rule2func[self.new2old[rule]](attr)501 def buildTree(self, nt, item, tokens, k):502 state, parent = item503 choices = []504 for rule in self.states[state].complete:505 if rule[0] == nt:506 choices.append(rule)507 rule = choices[0]508 if len(choices) > 1:509 rule = self.ambiguity(choices)510 #print rule511 rhs = rule[1]512 attr = [None] * len(rhs)513 for i in xrange(len(rhs)-1, -1, -1):514 sym = rhs[i]515 if not self.newrules.has_key(sym):516 if sym != self._BOF:517 attr[i] = tokens[k-1]518 key = (item, k)519 item, k = self.predecessor(key, None)520 #elif self.isnullable(sym):521 elif self._NULLABLE == sym[0:len(self._NULLABLE)]:522 attr[i] = self.deriveEpsilon(sym)523 else:524 key = (item, k)525 why = self.causal(key)526 attr[i] = self.buildTree(sym, why[0],527 tokens, why[1])528 item, k = self.predecessor(key, why)529 return self.rule2func[self.new2old[rule]](attr)530 def ambiguity(self, rules):531 #532 # XXX - problem here and in collectRules() if the same rule533 # appears in >1 method. Also undefined results if rules534 # causing the ambiguity appear in the same method.535 #536 537 sortlist = []538 name2index = {}539 for i in xrange(len(rules)):540 lhs, rhs = rule = rules[i]541 name = self.rule2name[self.new2old[rule]]542 sortlist.append((len(rhs), name))543 name2index[name] = i544 sortlist.sort()545 list = map(lambda (a,b): b, sortlist)546 return rules[name2index[self.resolve(list)]]...
adhoc
Source:adhoc
...155 return premises156 elif type(provenance) is list:157 return { premise for elem in provenance for premise in collectIntermediateConclusions(elem) }158 else: return set()159 def collectRules(provenance):160 if type(provenance) is dict:161 rules = { rule for key, value in provenance.items() for rule in collectRules(value) }162 if 'axiom' in provenance and provenance['axiom'].startswith('Rule'):163 rules = rules | { provenance['axiom'][len('Rule') + 1:-1] }164 return rules165 elif type(provenance) is list:166 rules = { rule for elem in provenance for rule in collectRules(elem) }167 return rules168 else: return set()169 def getProvenance(relName, t):170 provenance1 = execSouffleCmd('explain ' + printSouffleString(relName, t))171 provenance2 = json.loads(provenance1)172 provenance3 = cleanProvenanceJson(provenance2)173 provenance4 = squashDesirableConclusions(provenance3)174 175 # if provenance3 != provenance4:176 # logging.info(provenance3)177 # logging.info(provenance4)178 return provenance4179 def why(relName, t):180 provenance = getProvenance(relName, t)181 #for hypRelName, hypT in collectIntermediateConclusions(provenance):182 # if hypRelName in idbRelationsExpected and hypT not in idbRelationsExpected[hypRelName]:183 # logging.debug('Tuple {} depends on absurd hypothesis {}'.format((relName, t), (hypRelName, hypT)))184 # return None185 rules = collectRules(provenance)186 #print(rules)187 outputStr = "WHY constraint added: [not ("188 for ruleName in rules:189 outputStr += str(ruleName) + " and "190 outputStr = outputStr[:len(outputStr)-5]191 outputStr += ")] because "192 outputStr += str(t) + " is undesirable and produced"193 print(outputStr)194 #logging.info('Tuple {} depends on rules {}'.format((relName, t), sorted(rules)))195 ans = z3.BoolVal(True)196 for ruleName in rules: ans = z3.And(ans, allRuleNames[ruleName])197 return ans198 def whyNot():199 ans = z3.BoolVal(False)200 outputStr = "WHYNOT constraint added: ["201 for ruleName in allRuleNames:202 if ruleName not in currRuleSetLarge:203 ans = z3.Or(ans, allRuleNames[ruleName])204 outputStr += str(ruleName) + " or "205 outputStr = outputStr[:len(outputStr)-4]206 outputStr += "] because "207 outputStr += str(t) + " is desirable and unproduced"208 print(outputStr)209 return ans210 ################################################################################################################211 # 3c. Iterate over all tuples212 for relName in idbRelationsExpected:213 #logging.info(relName)214 relProduced = loadRelation(problemDirName + '/' + relName + '.csv')215 # 3c(i) Tuples which are expected and produced216 # We do not have anything to learn from these tuples217 #for t in relProduced & idbRelationsExpected[relName]:218 #logging.info('Solution produces desirable tuple: ' + printSouffleString(relName, t))219 # 3c(ii) Tuples which are unexpected but still produced220 # Here, we ask the question: ``Why was this tuple produced?''221 222 for t in relProduced - idbRelationsExpected[relName]:223 #logging.info('Solution produces undesirable tuple ' + printSouffleString(relName, t))224 solved = False225 whyRelT = why(relName, t)226 if whyRelT != None:227 solver.add(z3.Not(whyRelT))228 numWhy+=1229 doSanity()230 # 3c(iii) Tuples which were expected but not produced231 # Here, we ask the question: ``Why was this tuple not produced?''232 unproducedDesirable = False233 for t in idbRelationsExpected[relName] - relProduced:234 #logging.info('Solution fails to produce desirable tuple ' + printSouffleString(relName, t))235 solved = False236 unproducedDesirable = True237 if unproducedDesirable:238 whyNotRelT = whyNot()239 if whyNotRelT != None:240 solver.add(whyNotRelT)241 numWhyNot+=1242 doSanity()243 244 # pass245 ################################################################################################################246 # 3d. Find useful rules247 if solved:248 ans = { ruleName for relName in idbRelationsExpected \249 for t in idbRelationsExpected[relName] \250 for ruleName in collectRules(getProvenance(relName, t)) }251 print(ans)...
rule_manager.py
Source:rule_manager.py
1import subprocess as sp2import re3def main():4 lstAps = ['ap_h0', 'ap_d0', 'ap_v0']5 hshAps = collectRules(lstAps)6 for strAp in hshAps:7 print('------------------list for ap=%s\n%s' % (strAp, str(hshAps[strAp])))8 applyRules(hshAps)9 # Rule Collector10 # Run for at least about 20 seconds11 # Once past that threshold, keep running while more rules are still being collected for any APs12 # New rules must be compared with the old ones in case they are just being reordered in the list13 # When rules stabilize for a certain time window, save everything into a file that can be read before the experiment starts 14def collectRules(lstAps):15 """16 Collects forwarding rules from all APs given and returns them in the form of a 17 dictionary with all the APs names and lists containing each rule.18 """19 hshNodes = {}20 for pAp in lstAps:21 strAp = str(pAp)22 hshNodes[strAp] = list()23 proc = sp.Popen(['ovs-ofctl', 'dump-flows', strAp], stdout=sp.PIPE)24 # Extract only stdout from index 025 strOut = proc.communicate()[0]26 # Remove whitespace characters27 rules = strOut.replace(' ', '')28 # Extract each line as a separate rule...
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:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run avocado automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
