How to use parse method in Cypress

Best JavaScript code snippet using cypress

spec.py

Source:spec.py Github

copy

Full Screen

1#!/usr/bin/env python32from .error import Error3from .parse_enums import Acc, Emit, Key4LEX_BYTE_CLASSES = bytearray(b"\000\000\000\000\000\000\000\000\000\001\002\000\000\000\000\000"5                             b"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"6                             b"\001\003\004\005\006\007\007\007\007\007\010\011\012\013\014\015"7                             b"\016\017\020\020\020\020\020\020\021\021\022\007\007\007\023\007"8                             b"\007\024\024\024\025\026\024\027\027\027\027\027\027\027\027\027"9                             b"\027\027\027\027\027\030\027\027\027\027\027\031\032\033\007\027"10                             b"\007\034\035\024\025\036\037\027\027\040\027\027\041\027\042\027"11                             b"\027\027\043\044\045\046\027\027\027\027\027\047\050\051\007\000"12                             b"\052\052\052\052\052\052\052\052\052\052\052\052\052\052\052\052"13                             b"\053\053\053\053\053\053\053\053\053\053\053\053\053\053\053\053"14                             b"\054\054\054\054\054\054\054\054\054\054\054\054\054\054\054\054"15                             b"\054\054\054\054\054\054\054\054\054\054\054\054\054\054\054\054"16                             b"\055\055\056\056\056\056\056\056\056\056\056\056\056\056\056\056"17                             b"\056\056\056\056\056\056\056\056\056\056\056\056\056\056\056\056"18                             b"\057\060\060\060\060\060\060\060\060\060\060\060\060\061\060\060"19                             b"\062\063\063\063\064\055\055\055\055\055\055\055\055\055\055\055")20LEX_TRANSITIONS = [21    bytearray(b"\214\220\201\113\041\125\115\220\117\002\124\003\001\001\004\005\005\005\013\067"22              b"\001\001\001\001\001\120\220\121\001\001\001\024\031\001\014\001\001\020\001\122"23              b"\101\123\215\215\215\215\215\215\215\215\215\215\215"),24    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"25              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\001\001\001\001\001\223"26              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),27    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\004\005\005\005\013\223"28              b"\001\001\001\001\001\223\223\223\001\001\001\001\031\001\001\001\001\001\001\223"29              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),30    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\004\005\005\005\013\223"31              b"\001\001\001\001\001\223\223\223\001\001\001\001\034\001\001\001\001\001\001\223"32              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),33    bytearray(b"\324\324\324\324\324\324\324\324\324\001\324\001\006\001\001\001\001\001\013\324"34              b"\001\001\010\001\001\324\324\324\001\001\010\001\001\001\001\001\001\001\001\324"35              b"\324\324\324\324\324\324\324\324\324\324\324\324\324"),36    bytearray(b"\324\324\324\324\324\324\324\324\324\001\324\001\006\001\005\005\005\005\013\324"37              b"\001\001\010\001\001\324\324\324\001\001\010\001\001\001\001\001\001\001\001\324"38              b"\324\324\324\324\324\324\324\324\324\324\324\324\324"),39    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\007\007\007\007\013\223"40              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\001\001\001\001\001\223"41              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),42    bytearray(b"\325\325\325\325\325\325\325\325\325\001\325\001\001\001\007\007\007\007\013\325"43              b"\001\001\010\001\001\325\325\325\001\001\010\001\001\001\001\001\001\001\001\325"44              b"\325\325\325\325\325\325\325\325\325\325\325\325\325"),45    bytearray(b"\223\223\223\223\223\223\223\223\223\011\223\011\001\001\012\012\012\012\013\223"46              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\001\001\001\001\001\223"47              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),48    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\012\012\012\012\013\223"49              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\001\001\001\001\001\223"50              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),51    bytearray(b"\325\325\325\325\325\325\325\325\325\001\325\001\001\001\012\012\012\012\013\325"52              b"\001\001\001\001\001\325\325\325\001\001\001\001\001\001\001\001\001\001\001\325"53              b"\325\325\325\325\325\325\325\325\325\325\325\325\325"),54    bytearray(b"\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322"55              b"\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322\322"56              b"\322\322\322\322\322\322\322\322\322\322\322\322\322"),57    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"58              b"\001\001\001\001\001\223\223\223\037\001\001\001\001\001\001\001\001\001\015\223"59              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),60    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"61              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\016\001\001\001\001\001\223"62              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),63    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"64              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\017\001\001\001\001\001\223"65              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),66    bytearray(b"\314\314\314\314\314\314\314\314\314\001\314\001\001\001\001\001\001\001\013\314"67              b"\001\001\001\001\001\314\314\314\001\001\001\001\001\001\001\001\001\001\001\314"68              b"\314\314\314\314\314\314\314\314\314\314\314\314\314"),69    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"70              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\001\021\001\001\001\223"71              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),72    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"73              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\001\001\001\001\022\223"74              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),75    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"76              b"\001\001\001\001\001\223\223\223\001\001\023\001\001\001\001\001\001\001\001\223"77              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),78    bytearray(b"\315\315\315\315\315\315\315\315\315\001\315\001\001\001\001\001\001\001\013\315"79              b"\001\001\001\001\001\315\315\315\001\001\001\001\001\001\001\001\001\001\001\315"80              b"\315\315\315\315\315\315\315\315\315\315\315\315\315"),81    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"82              b"\001\001\001\001\001\223\223\223\025\001\001\001\001\001\001\001\001\001\001\223"83              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),84    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"85              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\026\001\001\001\001\001\223"86              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),87    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"88              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\001\001\027\001\001\223"89              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),90    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"91              b"\001\001\001\001\001\223\223\223\001\001\030\001\001\001\001\001\001\001\001\223"92              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),93    bytearray(b"\316\316\316\316\316\316\316\316\316\001\316\001\001\001\001\001\001\001\013\316"94              b"\001\001\001\001\001\316\316\316\001\001\001\001\001\001\001\001\001\001\001\316"95              b"\316\316\316\316\316\316\316\316\316\316\316\316\316"),96    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"97              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\032\001\001\001\001\223"98              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),99    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"100              b"\001\001\001\001\001\223\223\223\001\001\001\033\001\001\001\001\001\001\001\223"101              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),102    bytearray(b"\317\317\317\317\317\317\317\317\317\001\317\001\001\001\001\001\001\001\013\317"103              b"\001\001\001\001\001\317\317\317\001\001\001\001\001\001\001\001\001\001\001\317"104              b"\317\317\317\317\317\317\317\317\317\317\317\317\317"),105    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"106              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\035\001\001\001\001\223"107              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),108    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"109              b"\001\001\001\001\001\223\223\223\001\001\001\036\001\001\001\001\001\001\001\223"110              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),111    bytearray(b"\320\320\320\320\320\320\320\320\320\001\320\001\001\001\001\001\001\001\013\320"112              b"\001\001\001\001\001\320\320\320\001\001\001\001\001\001\001\001\001\001\001\320"113              b"\320\320\320\320\320\320\320\320\320\320\320\320\320"),114    bytearray(b"\223\223\223\223\223\223\223\223\223\001\223\001\001\001\001\001\001\001\013\223"115              b"\001\001\001\001\001\223\223\223\001\001\001\001\001\001\040\001\001\001\001\223"116              b"\223\223\223\223\223\223\223\223\223\223\223\223\223"),117    bytearray(b"\321\321\321\321\321\321\321\321\321\001\321\001\001\001\001\001\001\001\013\321"118              b"\001\001\001\001\001\321\321\321\001\001\001\001\001\001\001\001\001\001\001\321"119              b"\321\321\321\321\321\321\321\321\321\321\321\321\321"),120    bytearray(b"\214\041\226\041\065\041\041\041\041\041\041\041\041\041\041\041\041\041\041\041"121              b"\041\041\041\041\041\041\051\041\041\041\041\041\041\041\041\041\041\041\041\041"122              b"\041\041\216\216\216\216\050\042\047\043\044\046\045"),123    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"124              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"125              b"\217\217\217\217\050\217\217\217\217\217\217\217\217"),126    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"127              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"128              b"\217\217\050\050\217\217\217\217\217\217\217\217\217"),129    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"130              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"131              b"\217\217\217\047\047\217\217\217\217\217\217\217\217"),132    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"133              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"134              b"\217\217\047\217\217\217\217\217\217\217\217\217\217"),135    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"136              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"137              b"\217\217\047\047\047\217\217\217\217\217\217\217\217"),138    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"139              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"140              b"\217\217\050\050\050\217\217\217\217\217\217\217\217"),141    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"142              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"143              b"\217\217\041\041\041\217\217\217\217\217\217\217\217"),144    bytearray(b"\224\224\226\224\041\224\224\224\224\224\224\224\224\041\224\224\224\224\224\224"145              b"\224\224\224\224\052\224\041\224\224\041\224\041\224\224\041\041\224\041\060\224"146              b"\224\224\224\224\224\224\224\224\224\224\224\224\224"),147    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\053\225\225\225\225\225"148              b"\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225"149              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),150    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\054\225\225\225\225\225"151              b"\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225"152              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),153    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\056\055\225\225\225\225"154              b"\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225"155              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),156    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\057\225\225\225\225\225"157              b"\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225"158              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),159    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\060\057\057\057\225\225"160              b"\057\057\057\225\225\225\225\225\057\057\057\057\225\225\225\225\225\225\225\225"161              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),162    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\061\061\061\061\225\225"163              b"\061\061\061\225\225\225\225\225\061\061\061\061\225\225\225\225\225\225\225\225"164              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),165    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\061\061\061\061\225\225"166              b"\061\064\061\225\225\225\225\225\061\061\061\061\225\225\225\225\225\225\225\225"167              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),168    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\062\062\062\062\225\225"169              b"\062\062\062\225\225\225\225\225\062\062\062\062\225\225\225\225\225\225\225\225"170              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),171    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\063\063\063\063\225\225"172              b"\063\063\063\225\225\225\225\225\063\063\063\063\225\225\225\225\225\225\225\225"173              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),174    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\041\041\041\041\225\225"175              b"\041\041\041\225\225\225\225\225\041\041\041\041\225\225\225\225\225\225\225\225"176              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),177    bytearray(b"\225\225\226\225\225\225\225\225\225\225\225\225\225\225\062\062\062\225\225\225"178              b"\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225\225"179              b"\225\225\225\225\225\225\225\225\225\225\225\225\225"),180    bytearray(b"\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\066\327"181              b"\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327\327"182              b"\327\327\327\327\327\327\327\327\327\327\327\327\327"),183    bytearray(b"\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323"184              b"\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323\323"185              b"\323\323\323\323\323\323\323\323\323\323\323\323\323"),186    bytearray(b"\214\077\311\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100"187              b"\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100"188              b"\100\100\216\216\216\216\076\070\075\071\072\074\073"),189    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"190              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"191              b"\217\217\217\217\076\217\217\217\217\217\217\217\217"),192    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"193              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"194              b"\217\217\076\076\217\217\217\217\217\217\217\217\217"),195    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"196              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"197              b"\217\217\217\075\075\217\217\217\217\217\217\217\217"),198    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"199              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"200              b"\217\217\075\217\217\217\217\217\217\217\217\217\217"),201    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"202              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"203              b"\217\217\075\075\075\217\217\217\217\217\217\217\217"),204    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"205              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"206              b"\217\217\076\076\076\217\217\217\217\217\217\217\217"),207    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"208              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"209              b"\217\217\100\100\100\217\217\217\217\217\217\217\217"),210    bytearray(b"\214\100\311\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100"211              b"\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100"212              b"\100\100\216\216\216\216\076\070\075\071\072\074\073"),213    bytearray(b"\214\100\330\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100"214              b"\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100\100"215              b"\100\100\216\216\216\216\076\070\075\071\072\074\073"),216    bytearray(b"\214\111\312\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112"217              b"\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112"218              b"\112\112\216\216\216\216\110\102\107\103\104\106\105"),219    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"220              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"221              b"\217\217\217\217\110\217\217\217\217\217\217\217\217"),222    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"223              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"224              b"\217\217\110\110\217\217\217\217\217\217\217\217\217"),225    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"226              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"227              b"\217\217\217\107\107\217\217\217\217\217\217\217\217"),228    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"229              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"230              b"\217\217\107\217\217\217\217\217\217\217\217\217\217"),231    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"232              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"233              b"\217\217\107\107\107\217\217\217\217\217\217\217\217"),234    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"235              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"236              b"\217\217\110\110\110\217\217\217\217\217\217\217\217"),237    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"238              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"239              b"\217\217\112\112\112\217\217\217\217\217\217\217\217"),240    bytearray(b"\214\112\312\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112"241              b"\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112"242              b"\112\112\216\216\216\216\110\102\107\103\104\106\105"),243    bytearray(b"\214\112\331\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112"244              b"\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112\112"245              b"\112\112\216\216\216\216\110\102\107\103\104\106\105"),246    bytearray(b"\227\114\313\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227"247              b"\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227"248              b"\227\227\227\227\227\227\227\227\227\227\227\227\227"),249    bytearray(b"\214\227\313\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227"250              b"\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227\227"251              b"\227\227\215\215\215\215\215\215\215\215\215\215\215"),252    bytearray(b"\326\115\326\326\326\326\326\326\326\221\326\221\221\221\116\116\116\116\326\326"253              b"\116\116\116\221\221\326\326\326\116\116\116\116\221\221\221\221\221\221\221\326"254              b"\326\326\326\326\326\326\326\326\326\326\326\326\326"),255    bytearray(b"\222\222\222\222\222\222\222\222\222\221\222\221\221\221\115\115\115\115\222\222"256              b"\115\115\115\221\221\222\222\222\115\115\115\115\221\221\221\221\221\221\221\222"257              b"\222\222\222\222\222\222\222\222\222\222\222\222\222"),258    bytearray(b"\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303"259              b"\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303\303"260              b"\303\303\303\303\303\303\303\303\303\303\303\303\303"),261    bytearray(b"\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304"262              b"\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304\304"263              b"\304\304\304\304\304\304\304\304\304\304\304\304\304"),264    bytearray(b"\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305"265              b"\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305\305"266              b"\305\305\305\305\305\305\305\305\305\305\305\305\305"),267    bytearray(b"\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306"268              b"\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306\306"269              b"\306\306\306\306\306\306\306\306\306\306\306\306\306"),270    bytearray(b"\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307"271              b"\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307\307"272              b"\307\307\307\307\307\307\307\307\307\307\307\307\307"),273    bytearray(b"\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310"274              b"\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310\310"275              b"\310\310\310\310\310\310\310\310\310\310\310\310\310"),276    bytearray(b"\214\125\332\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125"277              b"\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125\125"278              b"\125\125\216\216\216\216\134\126\133\127\130\132\131"),279    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"280              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"281              b"\217\217\217\217\134\217\217\217\217\217\217\217\217"),282    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"283              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"284              b"\217\217\134\134\217\217\217\217\217\217\217\217\217"),285    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"286              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"287              b"\217\217\217\133\133\217\217\217\217\217\217\217\217"),288    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"289              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"290              b"\217\217\133\217\217\217\217\217\217\217\217\217\217"),291    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"292              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"293              b"\217\217\133\133\133\217\217\217\217\217\217\217\217"),294    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"295              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"296              b"\217\217\134\134\134\217\217\217\217\217\217\217\217"),297    bytearray(b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"298              b"\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217\217"299              b"\217\217\125\125\125\217\217\217\217\217\217\217\217"),300]301PARSE_DEFS = [302    (Error.LONG, None, [], [], None),303    (None, None, [1], [], None),304    (None, Emit.NULL, [], [], None),305    (None, Emit.TRUE, [], [], None),306    (None, Emit.FALSE, [], [], None),307    (None, Emit.INF, [], [], None),308    (None, Emit.NEG_INF, [], [], None),309    (None, Emit.NAN, [], [], None),310    (None, Emit.INT, [], [], None),311    (None, Emit.FLOAT, [], [], None),312    (None, Emit.STRING, [], [], None),313    (None, Emit.DATA, [], [], None),314    (None, Emit.SHORT_ARRAY_IN, [17], [], None),315    (None, Emit.SHORT_MAP_IN, [21], [], None),316    (None, None, [2], [], None),317    (None, Emit.NULL, [3], [], None),318    (None, Emit.TRUE, [3], [], None),319    (None, Emit.FALSE, [3], [], None),320    (None, Emit.INF, [3], [], None),321    (None, Emit.NEG_INF, [3], [], None),322    (None, Emit.NAN, [3], [], None),323    (None, Emit.INT, [3], [], None),324    (None, Emit.FLOAT, [3], [], None),325    (None, Emit.STRING, [3], [], None),326    (None, None, [9], [Acc.DATA], None),327    (None, None, [13], [Acc.STRING], None),328    (None, None, [11], [], None),329    (None, None, [15], [], None),330    (None, Emit.SHORT_ARRAY_IN, [3, 17], [], None),331    (None, Emit.LONG_ARRAY_IN, [19, 0], [], None),332    (None, Emit.SHORT_MAP_IN, [3, 21], [], None),333    (None, Emit.LONG_MAP_IN, [24, 0], [], Key.UNQUOTED),334    (None, Emit.LONG_MAP_IN, [24, 0], [], Key.QUOTED),335    (Error.SUFFIX, None, [], [], None),336    (None, None, [2, 5], [], None),337    (None, None, [3, 5], [], None),338    (None, None, [4], [], None),339    (None, None, [], [], None),340    (None, None, [3], [], None),341    (Error.SIBLING, None, [], [], None),342    (Error.CHILD, None, [], [], None),343    (None, None, [6], [], None),344    (None, None, [6, 5], [], None),345    (None, None, [5], [], None),346    (Error.SHORT, None, [], [], None),347    (None, None, [9], [], None),348    (None, None, [9, 5], [], None),349    (None, None, [8], [], None),350    (None, Emit.ACC_DATA, [], [], None),351    (None, None, [13], [Acc.NL, Acc.STRING], None),352    (None, None, [11], [Acc.NL], None),353    (None, None, [11, 5], [], None),354    (None, None, [10], [], None),355    (None, Emit.ACC_STRING, [], [Acc.NL], None),356    (None, None, [13], [], None),357    (None, None, [13], [Acc.SP, Acc.STRING], None),358    (None, None, [13, 5], [], None),359    (None, None, [12], [], None),360    (Error.BANG_LAST, None, [], [], None),361    (None, None, [15, 5], [], None),362    (None, None, [14], [], None),363    (None, Emit.ACC_STRING, [], [], None),364    (Error.ARRAY_END, None, [], [], None),365    (None, None, [16, 7], [], None),366    (None, Emit.SHORT_ARRAY_OUT, [], [], None),367    (None, Emit.NULL, [16], [], None),368    (None, Emit.TRUE, [16], [], None),369    (None, Emit.FALSE, [16], [], None),370    (None, Emit.INF, [16], [], None),371    (None, Emit.NEG_INF, [16], [], None),372    (None, Emit.NAN, [16], [], None),373    (None, Emit.INT, [16], [], None),374    (None, Emit.FLOAT, [16], [], None),375    (None, Emit.STRING, [16], [], None),376    (None, Emit.DATA, [16], [], None),377    (None, Emit.SHORT_ARRAY_IN, [16, 17], [], None),378    (None, Emit.SHORT_MAP_IN, [16, 21], [], None),379    (None, None, [19], [], None),380    (None, None, [19, 0], [], None),381    (None, None, [19, 5], [], None),382    (None, None, [18], [], None),383    (None, Emit.LONG_ARRAY_OUT, [], [], None),384    (Error.MAP_END, None, [], [], None),385    (None, None, [20, 22], [], None),386    (None, Emit.SHORT_MAP_OUT, [], [], None),387    (Error.MAP_KEY, None, [], [], None),388    (None, None, [20, 7], [], Key.UNQUOTED),389    (None, None, [20, 7], [], Key.QUOTED),390    (None, None, [7], [], Key.UNQUOTED),391    (None, None, [7], [], Key.QUOTED),392    (None, None, [24], [], None),393    (None, None, [24, 0], [], Key.UNQUOTED),394    (None, None, [24, 0], [], Key.QUOTED),395    (None, None, [24, 5], [], None),396    (None, None, [23], [], None),397    (None, Emit.LONG_MAP_OUT, [], [], None),398]399PARSE_TABLE = [400    [PARSE_DEFS[1], PARSE_DEFS[0], PARSE_DEFS[0], PARSE_DEFS[0], PARSE_DEFS[12],401     PARSE_DEFS[0], PARSE_DEFS[13], PARSE_DEFS[0], PARSE_DEFS[0], PARSE_DEFS[0],402     PARSE_DEFS[0], PARSE_DEFS[0], PARSE_DEFS[2], PARSE_DEFS[3], PARSE_DEFS[4],403     PARSE_DEFS[5], PARSE_DEFS[6], PARSE_DEFS[7], PARSE_DEFS[0], PARSE_DEFS[0],404     PARSE_DEFS[8], PARSE_DEFS[9], PARSE_DEFS[11], PARSE_DEFS[10], PARSE_DEFS[0],405     PARSE_DEFS[0], PARSE_DEFS[0]],406    [PARSE_DEFS[0], PARSE_DEFS[0], PARSE_DEFS[0], PARSE_DEFS[29], PARSE_DEFS[28],407     PARSE_DEFS[0], PARSE_DEFS[30], PARSE_DEFS[0], PARSE_DEFS[0], PARSE_DEFS[26],408     PARSE_DEFS[26], PARSE_DEFS[27], PARSE_DEFS[15], PARSE_DEFS[16], PARSE_DEFS[17],409     PARSE_DEFS[18], PARSE_DEFS[19], PARSE_DEFS[20], PARSE_DEFS[31], PARSE_DEFS[32],410     PARSE_DEFS[21], PARSE_DEFS[22], PARSE_DEFS[24], PARSE_DEFS[23], PARSE_DEFS[25],411     PARSE_DEFS[25], PARSE_DEFS[14]],412    [PARSE_DEFS[34], PARSE_DEFS[1], PARSE_DEFS[0], PARSE_DEFS[33], PARSE_DEFS[33],413     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],414     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],415     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],416     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],417     PARSE_DEFS[33], PARSE_DEFS[33]],418    [PARSE_DEFS[35], PARSE_DEFS[36], PARSE_DEFS[37], PARSE_DEFS[33], PARSE_DEFS[33],419     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],420     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],421     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],422     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],423     PARSE_DEFS[33], PARSE_DEFS[38]],424    [PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[0], PARSE_DEFS[39], PARSE_DEFS[39],425     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],426     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],427     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],428     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],429     PARSE_DEFS[39], PARSE_DEFS[38]],430    [PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[0], PARSE_DEFS[40], PARSE_DEFS[40],431     PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40],432     PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40],433     PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40],434     PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40], PARSE_DEFS[40],435     PARSE_DEFS[40], PARSE_DEFS[41]],436    [PARSE_DEFS[42], PARSE_DEFS[43], PARSE_DEFS[37], PARSE_DEFS[33], PARSE_DEFS[33],437     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],438     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],439     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],440     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],441     PARSE_DEFS[33], PARSE_DEFS[33]],442    [PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[12],443     PARSE_DEFS[44], PARSE_DEFS[13], PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[44],444     PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[2], PARSE_DEFS[3], PARSE_DEFS[4],445     PARSE_DEFS[5], PARSE_DEFS[6], PARSE_DEFS[7], PARSE_DEFS[44], PARSE_DEFS[44],446     PARSE_DEFS[8], PARSE_DEFS[9], PARSE_DEFS[11], PARSE_DEFS[10], PARSE_DEFS[44],447     PARSE_DEFS[44], PARSE_DEFS[44]],448    [PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],449     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],450     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],451     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],452     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[24], PARSE_DEFS[39], PARSE_DEFS[39],453     PARSE_DEFS[39], PARSE_DEFS[45]],454    [PARSE_DEFS[46], PARSE_DEFS[47], PARSE_DEFS[48], PARSE_DEFS[33], PARSE_DEFS[33],455     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],456     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],457     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],458     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],459     PARSE_DEFS[33], PARSE_DEFS[45]],460    [PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],461     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[50],462     PARSE_DEFS[50], PARSE_DEFS[27], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],463     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],464     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[49],465     PARSE_DEFS[49], PARSE_DEFS[26]],466    [PARSE_DEFS[51], PARSE_DEFS[52], PARSE_DEFS[53], PARSE_DEFS[33], PARSE_DEFS[33],467     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],468     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],469     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],470     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],471     PARSE_DEFS[33], PARSE_DEFS[33]],472    [PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],473     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[50],474     PARSE_DEFS[50], PARSE_DEFS[27], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],475     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],476     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[55],477     PARSE_DEFS[49], PARSE_DEFS[54]],478    [PARSE_DEFS[56], PARSE_DEFS[57], PARSE_DEFS[53], PARSE_DEFS[33], PARSE_DEFS[33],479     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],480     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],481     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],482     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],483     PARSE_DEFS[33], PARSE_DEFS[33]],484    [PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],485     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[58],486     PARSE_DEFS[58], PARSE_DEFS[58], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],487     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],488     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[58],489     PARSE_DEFS[58], PARSE_DEFS[27]],490    [PARSE_DEFS[59], PARSE_DEFS[60], PARSE_DEFS[61], PARSE_DEFS[33], PARSE_DEFS[33],491     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],492     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],493     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],494     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],495     PARSE_DEFS[33], PARSE_DEFS[33]],496    [PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62],497     PARSE_DEFS[64], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[63], PARSE_DEFS[62],498     PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62],499     PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62],500     PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62], PARSE_DEFS[62],501     PARSE_DEFS[62], PARSE_DEFS[62]],502    [PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[75],503     PARSE_DEFS[64], PARSE_DEFS[76], PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[44],504     PARSE_DEFS[44], PARSE_DEFS[44], PARSE_DEFS[65], PARSE_DEFS[66], PARSE_DEFS[67],505     PARSE_DEFS[68], PARSE_DEFS[69], PARSE_DEFS[70], PARSE_DEFS[44], PARSE_DEFS[44],506     PARSE_DEFS[71], PARSE_DEFS[72], PARSE_DEFS[74], PARSE_DEFS[73], PARSE_DEFS[44],507     PARSE_DEFS[44], PARSE_DEFS[44]],508    [PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[78], PARSE_DEFS[39],509     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],510     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],511     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],512     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],513     PARSE_DEFS[39], PARSE_DEFS[77]],514    [PARSE_DEFS[79], PARSE_DEFS[80], PARSE_DEFS[81], PARSE_DEFS[33], PARSE_DEFS[33],515     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],516     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],517     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],518     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],519     PARSE_DEFS[33], PARSE_DEFS[77]],520    [PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82],521     PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[84], PARSE_DEFS[83], PARSE_DEFS[82],522     PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82],523     PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82],524     PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82], PARSE_DEFS[82],525     PARSE_DEFS[82], PARSE_DEFS[82]],526    [PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85],527     PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[84], PARSE_DEFS[85], PARSE_DEFS[85],528     PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85],529     PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[86], PARSE_DEFS[87],530     PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85],531     PARSE_DEFS[85], PARSE_DEFS[85]],532    [PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85],533     PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85],534     PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85],535     PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[88], PARSE_DEFS[89],536     PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85], PARSE_DEFS[85],537     PARSE_DEFS[85], PARSE_DEFS[85]],538    [PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],539     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],540     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],541     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[91], PARSE_DEFS[92],542     PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39], PARSE_DEFS[39],543     PARSE_DEFS[39], PARSE_DEFS[90]],544    [PARSE_DEFS[93], PARSE_DEFS[94], PARSE_DEFS[95], PARSE_DEFS[33], PARSE_DEFS[33],545     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],546     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],547     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],548     PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33], PARSE_DEFS[33],549     PARSE_DEFS[33], PARSE_DEFS[90]],...

Full Screen

Full Screen

qasm3subListener.py

Source:qasm3subListener.py Github

copy

Full Screen

1# Generated from qasm3sub.g4 by ANTLR 4.9.22from antlr4 import *3if __name__ is not None and "." in __name__:4    from .qasm3subParser import qasm3subParser5else:6    from qasm3subParser import qasm3subParser7# This class defines a complete listener for a parse tree produced by qasm3subParser.8class qasm3subListener(ParseTreeListener):9    # Enter a parse tree produced by qasm3subParser#program.10    def enterProgram(self, ctx:qasm3subParser.ProgramContext):11        pass12    # Exit a parse tree produced by qasm3subParser#program.13    def exitProgram(self, ctx:qasm3subParser.ProgramContext):14        pass15    # Enter a parse tree produced by qasm3subParser#header.16    def enterHeader(self, ctx:qasm3subParser.HeaderContext):17        pass18    # Exit a parse tree produced by qasm3subParser#header.19    def exitHeader(self, ctx:qasm3subParser.HeaderContext):20        pass21    # Enter a parse tree produced by qasm3subParser#version.22    def enterVersion(self, ctx:qasm3subParser.VersionContext):23        pass24    # Exit a parse tree produced by qasm3subParser#version.25    def exitVersion(self, ctx:qasm3subParser.VersionContext):26        pass27    # Enter a parse tree produced by qasm3subParser#include.28    def enterInclude(self, ctx:qasm3subParser.IncludeContext):29        pass30    # Exit a parse tree produced by qasm3subParser#include.31    def exitInclude(self, ctx:qasm3subParser.IncludeContext):32        pass33    # Enter a parse tree produced by qasm3subParser#globalStatement.34    def enterGlobalStatement(self, ctx:qasm3subParser.GlobalStatementContext):35        pass36    # Exit a parse tree produced by qasm3subParser#globalStatement.37    def exitGlobalStatement(self, ctx:qasm3subParser.GlobalStatementContext):38        pass39    # Enter a parse tree produced by qasm3subParser#statement.40    def enterStatement(self, ctx:qasm3subParser.StatementContext):41        pass42    # Exit a parse tree produced by qasm3subParser#statement.43    def exitStatement(self, ctx:qasm3subParser.StatementContext):44        pass45    # Enter a parse tree produced by qasm3subParser#quantumDeclarationStatement.46    def enterQuantumDeclarationStatement(self, ctx:qasm3subParser.QuantumDeclarationStatementContext):47        pass48    # Exit a parse tree produced by qasm3subParser#quantumDeclarationStatement.49    def exitQuantumDeclarationStatement(self, ctx:qasm3subParser.QuantumDeclarationStatementContext):50        pass51    # Enter a parse tree produced by qasm3subParser#classicalDeclarationStatement.52    def enterClassicalDeclarationStatement(self, ctx:qasm3subParser.ClassicalDeclarationStatementContext):53        pass54    # Exit a parse tree produced by qasm3subParser#classicalDeclarationStatement.55    def exitClassicalDeclarationStatement(self, ctx:qasm3subParser.ClassicalDeclarationStatementContext):56        pass57    # Enter a parse tree produced by qasm3subParser#classicalAssignment.58    def enterClassicalAssignment(self, ctx:qasm3subParser.ClassicalAssignmentContext):59        pass60    # Exit a parse tree produced by qasm3subParser#classicalAssignment.61    def exitClassicalAssignment(self, ctx:qasm3subParser.ClassicalAssignmentContext):62        pass63    # Enter a parse tree produced by qasm3subParser#assignmentStatement.64    def enterAssignmentStatement(self, ctx:qasm3subParser.AssignmentStatementContext):65        pass66    # Exit a parse tree produced by qasm3subParser#assignmentStatement.67    def exitAssignmentStatement(self, ctx:qasm3subParser.AssignmentStatementContext):68        pass69    # Enter a parse tree produced by qasm3subParser#returnSignature.70    def enterReturnSignature(self, ctx:qasm3subParser.ReturnSignatureContext):71        pass72    # Exit a parse tree produced by qasm3subParser#returnSignature.73    def exitReturnSignature(self, ctx:qasm3subParser.ReturnSignatureContext):74        pass75    # Enter a parse tree produced by qasm3subParser#designator.76    def enterDesignator(self, ctx:qasm3subParser.DesignatorContext):77        pass78    # Exit a parse tree produced by qasm3subParser#designator.79    def exitDesignator(self, ctx:qasm3subParser.DesignatorContext):80        pass81    # Enter a parse tree produced by qasm3subParser#doubleDesignator.82    def enterDoubleDesignator(self, ctx:qasm3subParser.DoubleDesignatorContext):83        pass84    # Exit a parse tree produced by qasm3subParser#doubleDesignator.85    def exitDoubleDesignator(self, ctx:qasm3subParser.DoubleDesignatorContext):86        pass87    # Enter a parse tree produced by qasm3subParser#identifierList.88    def enterIdentifierList(self, ctx:qasm3subParser.IdentifierListContext):89        pass90    # Exit a parse tree produced by qasm3subParser#identifierList.91    def exitIdentifierList(self, ctx:qasm3subParser.IdentifierListContext):92        pass93    # Enter a parse tree produced by qasm3subParser#association.94    def enterAssociation(self, ctx:qasm3subParser.AssociationContext):95        pass96    # Exit a parse tree produced by qasm3subParser#association.97    def exitAssociation(self, ctx:qasm3subParser.AssociationContext):98        pass99    # Enter a parse tree produced by qasm3subParser#quantumType.100    def enterQuantumType(self, ctx:qasm3subParser.QuantumTypeContext):101        pass102    # Exit a parse tree produced by qasm3subParser#quantumType.103    def exitQuantumType(self, ctx:qasm3subParser.QuantumTypeContext):104        pass105    # Enter a parse tree produced by qasm3subParser#quantumDeclaration.106    def enterQuantumDeclaration(self, ctx:qasm3subParser.QuantumDeclarationContext):107        pass108    # Exit a parse tree produced by qasm3subParser#quantumDeclaration.109    def exitQuantumDeclaration(self, ctx:qasm3subParser.QuantumDeclarationContext):110        pass111    # Enter a parse tree produced by qasm3subParser#quantumArgument.112    def enterQuantumArgument(self, ctx:qasm3subParser.QuantumArgumentContext):113        pass114    # Exit a parse tree produced by qasm3subParser#quantumArgument.115    def exitQuantumArgument(self, ctx:qasm3subParser.QuantumArgumentContext):116        pass117    # Enter a parse tree produced by qasm3subParser#quantumArgumentList.118    def enterQuantumArgumentList(self, ctx:qasm3subParser.QuantumArgumentListContext):119        pass120    # Exit a parse tree produced by qasm3subParser#quantumArgumentList.121    def exitQuantumArgumentList(self, ctx:qasm3subParser.QuantumArgumentListContext):122        pass123    # Enter a parse tree produced by qasm3subParser#bitType.124    def enterBitType(self, ctx:qasm3subParser.BitTypeContext):125        pass126    # Exit a parse tree produced by qasm3subParser#bitType.127    def exitBitType(self, ctx:qasm3subParser.BitTypeContext):128        pass129    # Enter a parse tree produced by qasm3subParser#singleDesignatorType.130    def enterSingleDesignatorType(self, ctx:qasm3subParser.SingleDesignatorTypeContext):131        pass132    # Exit a parse tree produced by qasm3subParser#singleDesignatorType.133    def exitSingleDesignatorType(self, ctx:qasm3subParser.SingleDesignatorTypeContext):134        pass135    # Enter a parse tree produced by qasm3subParser#doubleDesignatorType.136    def enterDoubleDesignatorType(self, ctx:qasm3subParser.DoubleDesignatorTypeContext):137        pass138    # Exit a parse tree produced by qasm3subParser#doubleDesignatorType.139    def exitDoubleDesignatorType(self, ctx:qasm3subParser.DoubleDesignatorTypeContext):140        pass141    # Enter a parse tree produced by qasm3subParser#noDesignatorType.142    def enterNoDesignatorType(self, ctx:qasm3subParser.NoDesignatorTypeContext):143        pass144    # Exit a parse tree produced by qasm3subParser#noDesignatorType.145    def exitNoDesignatorType(self, ctx:qasm3subParser.NoDesignatorTypeContext):146        pass147    # Enter a parse tree produced by qasm3subParser#classicalType.148    def enterClassicalType(self, ctx:qasm3subParser.ClassicalTypeContext):149        pass150    # Exit a parse tree produced by qasm3subParser#classicalType.151    def exitClassicalType(self, ctx:qasm3subParser.ClassicalTypeContext):152        pass153    # Enter a parse tree produced by qasm3subParser#constantDeclaration.154    def enterConstantDeclaration(self, ctx:qasm3subParser.ConstantDeclarationContext):155        pass156    # Exit a parse tree produced by qasm3subParser#constantDeclaration.157    def exitConstantDeclaration(self, ctx:qasm3subParser.ConstantDeclarationContext):158        pass159    # Enter a parse tree produced by qasm3subParser#singleDesignatorDeclaration.160    def enterSingleDesignatorDeclaration(self, ctx:qasm3subParser.SingleDesignatorDeclarationContext):161        pass162    # Exit a parse tree produced by qasm3subParser#singleDesignatorDeclaration.163    def exitSingleDesignatorDeclaration(self, ctx:qasm3subParser.SingleDesignatorDeclarationContext):164        pass165    # Enter a parse tree produced by qasm3subParser#doubleDesignatorDeclaration.166    def enterDoubleDesignatorDeclaration(self, ctx:qasm3subParser.DoubleDesignatorDeclarationContext):167        pass168    # Exit a parse tree produced by qasm3subParser#doubleDesignatorDeclaration.169    def exitDoubleDesignatorDeclaration(self, ctx:qasm3subParser.DoubleDesignatorDeclarationContext):170        pass171    # Enter a parse tree produced by qasm3subParser#noDesignatorDeclaration.172    def enterNoDesignatorDeclaration(self, ctx:qasm3subParser.NoDesignatorDeclarationContext):173        pass174    # Exit a parse tree produced by qasm3subParser#noDesignatorDeclaration.175    def exitNoDesignatorDeclaration(self, ctx:qasm3subParser.NoDesignatorDeclarationContext):176        pass177    # Enter a parse tree produced by qasm3subParser#bitDeclaration.178    def enterBitDeclaration(self, ctx:qasm3subParser.BitDeclarationContext):179        pass180    # Exit a parse tree produced by qasm3subParser#bitDeclaration.181    def exitBitDeclaration(self, ctx:qasm3subParser.BitDeclarationContext):182        pass183    # Enter a parse tree produced by qasm3subParser#classicalDeclaration.184    def enterClassicalDeclaration(self, ctx:qasm3subParser.ClassicalDeclarationContext):185        pass186    # Exit a parse tree produced by qasm3subParser#classicalDeclaration.187    def exitClassicalDeclaration(self, ctx:qasm3subParser.ClassicalDeclarationContext):188        pass189    # Enter a parse tree produced by qasm3subParser#classicalArgument.190    def enterClassicalArgument(self, ctx:qasm3subParser.ClassicalArgumentContext):191        pass192    # Exit a parse tree produced by qasm3subParser#classicalArgument.193    def exitClassicalArgument(self, ctx:qasm3subParser.ClassicalArgumentContext):194        pass195    # Enter a parse tree produced by qasm3subParser#classicalArgumentList.196    def enterClassicalArgumentList(self, ctx:qasm3subParser.ClassicalArgumentListContext):197        pass198    # Exit a parse tree produced by qasm3subParser#classicalArgumentList.199    def exitClassicalArgumentList(self, ctx:qasm3subParser.ClassicalArgumentListContext):200        pass201    # Enter a parse tree produced by qasm3subParser#aliasStatement.202    def enterAliasStatement(self, ctx:qasm3subParser.AliasStatementContext):203        pass204    # Exit a parse tree produced by qasm3subParser#aliasStatement.205    def exitAliasStatement(self, ctx:qasm3subParser.AliasStatementContext):206        pass207    # Enter a parse tree produced by qasm3subParser#indexIdentifier.208    def enterIndexIdentifier(self, ctx:qasm3subParser.IndexIdentifierContext):209        pass210    # Exit a parse tree produced by qasm3subParser#indexIdentifier.211    def exitIndexIdentifier(self, ctx:qasm3subParser.IndexIdentifierContext):212        pass213    # Enter a parse tree produced by qasm3subParser#indexIdentifierList.214    def enterIndexIdentifierList(self, ctx:qasm3subParser.IndexIdentifierListContext):215        pass216    # Exit a parse tree produced by qasm3subParser#indexIdentifierList.217    def exitIndexIdentifierList(self, ctx:qasm3subParser.IndexIdentifierListContext):218        pass219    # Enter a parse tree produced by qasm3subParser#indexEqualsAssignmentList.220    def enterIndexEqualsAssignmentList(self, ctx:qasm3subParser.IndexEqualsAssignmentListContext):221        pass222    # Exit a parse tree produced by qasm3subParser#indexEqualsAssignmentList.223    def exitIndexEqualsAssignmentList(self, ctx:qasm3subParser.IndexEqualsAssignmentListContext):224        pass225    # Enter a parse tree produced by qasm3subParser#rangeDefinition.226    def enterRangeDefinition(self, ctx:qasm3subParser.RangeDefinitionContext):227        pass228    # Exit a parse tree produced by qasm3subParser#rangeDefinition.229    def exitRangeDefinition(self, ctx:qasm3subParser.RangeDefinitionContext):230        pass231    # Enter a parse tree produced by qasm3subParser#quantumGateDefinition.232    def enterQuantumGateDefinition(self, ctx:qasm3subParser.QuantumGateDefinitionContext):233        pass234    # Exit a parse tree produced by qasm3subParser#quantumGateDefinition.235    def exitQuantumGateDefinition(self, ctx:qasm3subParser.QuantumGateDefinitionContext):236        pass237    # Enter a parse tree produced by qasm3subParser#quantumGateSignature.238    def enterQuantumGateSignature(self, ctx:qasm3subParser.QuantumGateSignatureContext):239        pass240    # Exit a parse tree produced by qasm3subParser#quantumGateSignature.241    def exitQuantumGateSignature(self, ctx:qasm3subParser.QuantumGateSignatureContext):242        pass243    # Enter a parse tree produced by qasm3subParser#quantumBlock.244    def enterQuantumBlock(self, ctx:qasm3subParser.QuantumBlockContext):245        pass246    # Exit a parse tree produced by qasm3subParser#quantumBlock.247    def exitQuantumBlock(self, ctx:qasm3subParser.QuantumBlockContext):248        pass249    # Enter a parse tree produced by qasm3subParser#quantumLoop.250    def enterQuantumLoop(self, ctx:qasm3subParser.QuantumLoopContext):251        pass252    # Exit a parse tree produced by qasm3subParser#quantumLoop.253    def exitQuantumLoop(self, ctx:qasm3subParser.QuantumLoopContext):254        pass255    # Enter a parse tree produced by qasm3subParser#quantumLoopBlock.256    def enterQuantumLoopBlock(self, ctx:qasm3subParser.QuantumLoopBlockContext):257        pass258    # Exit a parse tree produced by qasm3subParser#quantumLoopBlock.259    def exitQuantumLoopBlock(self, ctx:qasm3subParser.QuantumLoopBlockContext):260        pass261    # Enter a parse tree produced by qasm3subParser#quantumStatement.262    def enterQuantumStatement(self, ctx:qasm3subParser.QuantumStatementContext):263        pass264    # Exit a parse tree produced by qasm3subParser#quantumStatement.265    def exitQuantumStatement(self, ctx:qasm3subParser.QuantumStatementContext):266        pass267    # Enter a parse tree produced by qasm3subParser#quantumInstruction.268    def enterQuantumInstruction(self, ctx:qasm3subParser.QuantumInstructionContext):269        pass270    # Exit a parse tree produced by qasm3subParser#quantumInstruction.271    def exitQuantumInstruction(self, ctx:qasm3subParser.QuantumInstructionContext):272        pass273    # Enter a parse tree produced by qasm3subParser#quantumPhase.274    def enterQuantumPhase(self, ctx:qasm3subParser.QuantumPhaseContext):275        pass276    # Exit a parse tree produced by qasm3subParser#quantumPhase.277    def exitQuantumPhase(self, ctx:qasm3subParser.QuantumPhaseContext):278        pass279    # Enter a parse tree produced by qasm3subParser#quantumMeasurement.280    def enterQuantumMeasurement(self, ctx:qasm3subParser.QuantumMeasurementContext):281        pass282    # Exit a parse tree produced by qasm3subParser#quantumMeasurement.283    def exitQuantumMeasurement(self, ctx:qasm3subParser.QuantumMeasurementContext):284        pass285    # Enter a parse tree produced by qasm3subParser#quantumMeasurementAssignment.286    def enterQuantumMeasurementAssignment(self, ctx:qasm3subParser.QuantumMeasurementAssignmentContext):287        pass288    # Exit a parse tree produced by qasm3subParser#quantumMeasurementAssignment.289    def exitQuantumMeasurementAssignment(self, ctx:qasm3subParser.QuantumMeasurementAssignmentContext):290        pass291    # Enter a parse tree produced by qasm3subParser#quantumBarrier.292    def enterQuantumBarrier(self, ctx:qasm3subParser.QuantumBarrierContext):293        pass294    # Exit a parse tree produced by qasm3subParser#quantumBarrier.295    def exitQuantumBarrier(self, ctx:qasm3subParser.QuantumBarrierContext):296        pass297    # Enter a parse tree produced by qasm3subParser#quantumGateModifier.298    def enterQuantumGateModifier(self, ctx:qasm3subParser.QuantumGateModifierContext):299        pass300    # Exit a parse tree produced by qasm3subParser#quantumGateModifier.301    def exitQuantumGateModifier(self, ctx:qasm3subParser.QuantumGateModifierContext):302        pass303    # Enter a parse tree produced by qasm3subParser#quantumGateCall.304    def enterQuantumGateCall(self, ctx:qasm3subParser.QuantumGateCallContext):305        pass306    # Exit a parse tree produced by qasm3subParser#quantumGateCall.307    def exitQuantumGateCall(self, ctx:qasm3subParser.QuantumGateCallContext):308        pass309    # Enter a parse tree produced by qasm3subParser#quantumGateName.310    def enterQuantumGateName(self, ctx:qasm3subParser.QuantumGateNameContext):311        pass312    # Exit a parse tree produced by qasm3subParser#quantumGateName.313    def exitQuantumGateName(self, ctx:qasm3subParser.QuantumGateNameContext):314        pass315    # Enter a parse tree produced by qasm3subParser#unaryOperator.316    def enterUnaryOperator(self, ctx:qasm3subParser.UnaryOperatorContext):317        pass318    # Exit a parse tree produced by qasm3subParser#unaryOperator.319    def exitUnaryOperator(self, ctx:qasm3subParser.UnaryOperatorContext):320        pass321    # Enter a parse tree produced by qasm3subParser#relationalOperator.322    def enterRelationalOperator(self, ctx:qasm3subParser.RelationalOperatorContext):323        pass324    # Exit a parse tree produced by qasm3subParser#relationalOperator.325    def exitRelationalOperator(self, ctx:qasm3subParser.RelationalOperatorContext):326        pass327    # Enter a parse tree produced by qasm3subParser#logicalOperator.328    def enterLogicalOperator(self, ctx:qasm3subParser.LogicalOperatorContext):329        pass330    # Exit a parse tree produced by qasm3subParser#logicalOperator.331    def exitLogicalOperator(self, ctx:qasm3subParser.LogicalOperatorContext):332        pass333    # Enter a parse tree produced by qasm3subParser#expressionStatement.334    def enterExpressionStatement(self, ctx:qasm3subParser.ExpressionStatementContext):335        pass336    # Exit a parse tree produced by qasm3subParser#expressionStatement.337    def exitExpressionStatement(self, ctx:qasm3subParser.ExpressionStatementContext):338        pass339    # Enter a parse tree produced by qasm3subParser#expression.340    def enterExpression(self, ctx:qasm3subParser.ExpressionContext):341        pass342    # Exit a parse tree produced by qasm3subParser#expression.343    def exitExpression(self, ctx:qasm3subParser.ExpressionContext):344        pass345    # Enter a parse tree produced by qasm3subParser#xOrExpression.346    def enterXOrExpression(self, ctx:qasm3subParser.XOrExpressionContext):347        pass348    # Exit a parse tree produced by qasm3subParser#xOrExpression.349    def exitXOrExpression(self, ctx:qasm3subParser.XOrExpressionContext):350        pass351    # Enter a parse tree produced by qasm3subParser#bitAndExpression.352    def enterBitAndExpression(self, ctx:qasm3subParser.BitAndExpressionContext):353        pass354    # Exit a parse tree produced by qasm3subParser#bitAndExpression.355    def exitBitAndExpression(self, ctx:qasm3subParser.BitAndExpressionContext):356        pass357    # Enter a parse tree produced by qasm3subParser#bitShiftExpression.358    def enterBitShiftExpression(self, ctx:qasm3subParser.BitShiftExpressionContext):359        pass360    # Exit a parse tree produced by qasm3subParser#bitShiftExpression.361    def exitBitShiftExpression(self, ctx:qasm3subParser.BitShiftExpressionContext):362        pass363    # Enter a parse tree produced by qasm3subParser#additiveExpression.364    def enterAdditiveExpression(self, ctx:qasm3subParser.AdditiveExpressionContext):365        pass366    # Exit a parse tree produced by qasm3subParser#additiveExpression.367    def exitAdditiveExpression(self, ctx:qasm3subParser.AdditiveExpressionContext):368        pass369    # Enter a parse tree produced by qasm3subParser#multiplicativeExpression.370    def enterMultiplicativeExpression(self, ctx:qasm3subParser.MultiplicativeExpressionContext):371        pass372    # Exit a parse tree produced by qasm3subParser#multiplicativeExpression.373    def exitMultiplicativeExpression(self, ctx:qasm3subParser.MultiplicativeExpressionContext):374        pass375    # Enter a parse tree produced by qasm3subParser#unaryExpression.376    def enterUnaryExpression(self, ctx:qasm3subParser.UnaryExpressionContext):377        pass378    # Exit a parse tree produced by qasm3subParser#unaryExpression.379    def exitUnaryExpression(self, ctx:qasm3subParser.UnaryExpressionContext):380        pass381    # Enter a parse tree produced by qasm3subParser#expressionTerminator.382    def enterExpressionTerminator(self, ctx:qasm3subParser.ExpressionTerminatorContext):383        pass384    # Exit a parse tree produced by qasm3subParser#expressionTerminator.385    def exitExpressionTerminator(self, ctx:qasm3subParser.ExpressionTerminatorContext):386        pass387    # Enter a parse tree produced by qasm3subParser#incrementor.388    def enterIncrementor(self, ctx:qasm3subParser.IncrementorContext):389        pass390    # Exit a parse tree produced by qasm3subParser#incrementor.391    def exitIncrementor(self, ctx:qasm3subParser.IncrementorContext):392        pass393    # Enter a parse tree produced by qasm3subParser#builtInCall.394    def enterBuiltInCall(self, ctx:qasm3subParser.BuiltInCallContext):395        pass396    # Exit a parse tree produced by qasm3subParser#builtInCall.397    def exitBuiltInCall(self, ctx:qasm3subParser.BuiltInCallContext):398        pass399    # Enter a parse tree produced by qasm3subParser#builtInMath.400    def enterBuiltInMath(self, ctx:qasm3subParser.BuiltInMathContext):401        pass402    # Exit a parse tree produced by qasm3subParser#builtInMath.403    def exitBuiltInMath(self, ctx:qasm3subParser.BuiltInMathContext):404        pass405    # Enter a parse tree produced by qasm3subParser#castOperator.406    def enterCastOperator(self, ctx:qasm3subParser.CastOperatorContext):407        pass408    # Exit a parse tree produced by qasm3subParser#castOperator.409    def exitCastOperator(self, ctx:qasm3subParser.CastOperatorContext):410        pass411    # Enter a parse tree produced by qasm3subParser#expressionList.412    def enterExpressionList(self, ctx:qasm3subParser.ExpressionListContext):413        pass414    # Exit a parse tree produced by qasm3subParser#expressionList.415    def exitExpressionList(self, ctx:qasm3subParser.ExpressionListContext):416        pass417    # Enter a parse tree produced by qasm3subParser#booleanExpression.418    def enterBooleanExpression(self, ctx:qasm3subParser.BooleanExpressionContext):419        pass420    # Exit a parse tree produced by qasm3subParser#booleanExpression.421    def exitBooleanExpression(self, ctx:qasm3subParser.BooleanExpressionContext):422        pass423    # Enter a parse tree produced by qasm3subParser#comparisonExpression.424    def enterComparisonExpression(self, ctx:qasm3subParser.ComparisonExpressionContext):425        pass426    # Exit a parse tree produced by qasm3subParser#comparisonExpression.427    def exitComparisonExpression(self, ctx:qasm3subParser.ComparisonExpressionContext):428        pass429    # Enter a parse tree produced by qasm3subParser#equalsExpression.430    def enterEqualsExpression(self, ctx:qasm3subParser.EqualsExpressionContext):431        pass432    # Exit a parse tree produced by qasm3subParser#equalsExpression.433    def exitEqualsExpression(self, ctx:qasm3subParser.EqualsExpressionContext):434        pass435    # Enter a parse tree produced by qasm3subParser#assignmentOperator.436    def enterAssignmentOperator(self, ctx:qasm3subParser.AssignmentOperatorContext):437        pass438    # Exit a parse tree produced by qasm3subParser#assignmentOperator.439    def exitAssignmentOperator(self, ctx:qasm3subParser.AssignmentOperatorContext):440        pass441    # Enter a parse tree produced by qasm3subParser#equalsAssignmentList.442    def enterEqualsAssignmentList(self, ctx:qasm3subParser.EqualsAssignmentListContext):443        pass444    # Exit a parse tree produced by qasm3subParser#equalsAssignmentList.445    def exitEqualsAssignmentList(self, ctx:qasm3subParser.EqualsAssignmentListContext):446        pass447    # Enter a parse tree produced by qasm3subParser#membershipTest.448    def enterMembershipTest(self, ctx:qasm3subParser.MembershipTestContext):449        pass450    # Exit a parse tree produced by qasm3subParser#membershipTest.451    def exitMembershipTest(self, ctx:qasm3subParser.MembershipTestContext):452        pass453    # Enter a parse tree produced by qasm3subParser#setDeclaration.454    def enterSetDeclaration(self, ctx:qasm3subParser.SetDeclarationContext):455        pass456    # Exit a parse tree produced by qasm3subParser#setDeclaration.457    def exitSetDeclaration(self, ctx:qasm3subParser.SetDeclarationContext):458        pass459    # Enter a parse tree produced by qasm3subParser#programBlock.460    def enterProgramBlock(self, ctx:qasm3subParser.ProgramBlockContext):461        pass462    # Exit a parse tree produced by qasm3subParser#programBlock.463    def exitProgramBlock(self, ctx:qasm3subParser.ProgramBlockContext):464        pass465    # Enter a parse tree produced by qasm3subParser#branchingStatement.466    def enterBranchingStatement(self, ctx:qasm3subParser.BranchingStatementContext):467        pass468    # Exit a parse tree produced by qasm3subParser#branchingStatement.469    def exitBranchingStatement(self, ctx:qasm3subParser.BranchingStatementContext):470        pass471    # Enter a parse tree produced by qasm3subParser#loopSignature.472    def enterLoopSignature(self, ctx:qasm3subParser.LoopSignatureContext):473        pass474    # Exit a parse tree produced by qasm3subParser#loopSignature.475    def exitLoopSignature(self, ctx:qasm3subParser.LoopSignatureContext):476        pass477    # Enter a parse tree produced by qasm3subParser#loopStatement.478    def enterLoopStatement(self, ctx:qasm3subParser.LoopStatementContext):479        pass480    # Exit a parse tree produced by qasm3subParser#loopStatement.481    def exitLoopStatement(self, ctx:qasm3subParser.LoopStatementContext):482        pass483    # Enter a parse tree produced by qasm3subParser#controlDirectiveStatement.484    def enterControlDirectiveStatement(self, ctx:qasm3subParser.ControlDirectiveStatementContext):485        pass486    # Exit a parse tree produced by qasm3subParser#controlDirectiveStatement.487    def exitControlDirectiveStatement(self, ctx:qasm3subParser.ControlDirectiveStatementContext):488        pass489    # Enter a parse tree produced by qasm3subParser#controlDirective.490    def enterControlDirective(self, ctx:qasm3subParser.ControlDirectiveContext):491        pass492    # Exit a parse tree produced by qasm3subParser#controlDirective.493    def exitControlDirective(self, ctx:qasm3subParser.ControlDirectiveContext):494        pass495    # Enter a parse tree produced by qasm3subParser#subroutineDefinition.496    def enterSubroutineDefinition(self, ctx:qasm3subParser.SubroutineDefinitionContext):497        pass498    # Exit a parse tree produced by qasm3subParser#subroutineDefinition.499    def exitSubroutineDefinition(self, ctx:qasm3subParser.SubroutineDefinitionContext):500        pass501    # Enter a parse tree produced by qasm3subParser#returnStatement.502    def enterReturnStatement(self, ctx:qasm3subParser.ReturnStatementContext):503        pass504    # Exit a parse tree produced by qasm3subParser#returnStatement.505    def exitReturnStatement(self, ctx:qasm3subParser.ReturnStatementContext):506        pass507    # Enter a parse tree produced by qasm3subParser#subroutineBlock.508    def enterSubroutineBlock(self, ctx:qasm3subParser.SubroutineBlockContext):509        pass510    # Exit a parse tree produced by qasm3subParser#subroutineBlock.511    def exitSubroutineBlock(self, ctx:qasm3subParser.SubroutineBlockContext):512        pass513    # Enter a parse tree produced by qasm3subParser#subroutineCall.514    def enterSubroutineCall(self, ctx:qasm3subParser.SubroutineCallContext):515        pass516    # Exit a parse tree produced by qasm3subParser#subroutineCall.517    def exitSubroutineCall(self, ctx:qasm3subParser.SubroutineCallContext):518        pass519    # Enter a parse tree produced by qasm3subParser#pragma.520    def enterPragma(self, ctx:qasm3subParser.PragmaContext):521        pass522    # Exit a parse tree produced by qasm3subParser#pragma.523    def exitPragma(self, ctx:qasm3subParser.PragmaContext):524        pass...

Full Screen

Full Screen

tsmells2gdfTest.py

Source:tsmells2gdfTest.py Github

copy

Full Screen

...27SMELL_NODE_COLOR = "red"28class RootTest(TestCase):29    ''' abstract root test'''30    def verifyParse(self, parser, toParse, key, location):31        parser.parse(toParse)32        self.assertTrue(parser.hasKey(key))33        self.assertEquals(location, parser.getLocation(key))34    def verifyGenerateNodes(self, generator, expNode):35        generator.parse(self.toParse)36        nodes = generator.generateNodes()37        self.assertEquals(1, len(nodes))38        self.assertTrue(expNode in nodes)39    def verifyGenerateMultiNodes(self, generator, expNode, expNode2, line1, line2):40        generator.parse(line1)41        generator.parse(line2)42        nodes = generator.generateNodes()43        self.assertEquals(2, len(nodes))44        self.assertTrue(expNode in nodes)45        self.assertTrue(expNode2 in nodes)46    def verifyAppendLocationInfo(self, generator, key, toParse, location):47        generator.parse(toParse)48        srcDict = {}49        generator.appendLocationInfo(srcDict)50        self.assertEqual(1, len(srcDict))51        self.assertTrue(key in srcDict)52        self.assertTrue(self.location in srcDict[key])53    def verifyAppendMetricsInfo(self, generator, identif, toParse, metricVal):54        generator.parse(self.toParse)55        metricDict = self.setupMetricDict()56        generator.appendMetricInfo(metricDict)57        self.assertTrue(identif in metricDict)58        metrics = metricDict[identif]59        self.assertEquals(1, len(metrics), \60                        "Should contain a single indentedtest metric dict")61        self.assertTrue(identif + "0" in metrics)62        metrics = metrics[identif + "0"]63        for name, val in metricVal:64            self.assertEquals(val, metrics[name]) 65    def setupMetricDict(self):66        metricDict = {}67        metricDict['Translation'] = {}68        return metricDict69    70class TestCasesTest(RootTest):71    def setUp(self):72        self.cases = TestCases()73        self.toParse = ["TestCase","FooTest","FooTest.java","2"]74        self.key = "FooTest"75        self.location = ("FooTest.java", 2)76        self.edgeColor = "lightgray"77        self.expNode = Node(name=self.key, color="black",\78                     label=self.key, entity="testcase", \79                    style=1, isSrcEnt=1)80    def testParse(self):81        self.verifyParse(self.cases, self.toParse, self.key, self.location)82    def testParsePkged(self):83        toParse = ["TestCase","pkg::FooTest","pkg/FooTest.java","2"]84        key = "pkg::FooTest"85        location = ("pkg/FooTest.java", 2)86        self.cases.parse(toParse)87        self.assertTrue(self.cases.pkgDict.has_key('pkg'))88        self.assertEquals(['pkg::FooTest'], self.cases.pkgDict['pkg'])89    def testParseDefaultPkg(self):90        self.verifyParseModule('FooTest', 'FooTest.java', 'default')91    def testParseModule(self):92        self.verifyParseModule('FooTest', "module/FooTest.cpp", 'module')93    def testParseModule2(self):94        self.verifyParseModule('FooTest', "testmessenger/FooTest.java", 'testmessenger')95    def testParseMultiLevelModule(self):96        self.verifyParseModule('FooTest', 'module/test/stuff/FooTest.cpp', 'module::test::stuff')97    def testParseModuleSkipSrc(self):98        # remove trailing 'src' from a module99        self.verifyParseModule('FooTest', 'module/test/src/FooTest.cpp', 'module::test')100    def verifyParseModule(self, clazz, file, module):101        self.toParse[2] = file102        self.cases.parse(self.toParse)103        self.assertTrue(self.cases.pkgDict.has_key(module), \104                        module + " not in " + str(self.cases.pkgDict))105        self.assertEquals([clazz], self.cases.pkgDict[module])106    def buildDefaultPkgNode(self):107        return Node('default', 'black', 'package', 'default', 1)108    def testGenerateNodes(self):109        self.cases.parse(self.toParse)110        nodes = self.cases.generateNodes()111        self.assertEquals(2, len(nodes))112        self.assertTrue(self.expNode in nodes)113        self.assertTrue(self.buildDefaultPkgNode() in nodes)114        115    def testGenerateNodesMulti(self):116        self.cases.parse(self.toParse)117        toParse2 = ["TestCase","BarTest","BarTest.java","3"]118        self.cases.parse(toParse2)119        toParse3 = ["TestCase","BazTest","BazTest.java","5"]        120        self.cases.parse(toParse3)121        nodes = self.cases.generateNodes()122        self.assertEquals(4, len(nodes), str([str(node) for node in nodes]))123        self.assertTrue(self.expNode in nodes)124        expNode2 = Node("BarTest", "black", \125                        "testcase", "BarTest", 1, isSrcEnt=1)126        expNode3 = Node("BazTest", "black", \127                        "testcase","BazTest", 1, isSrcEnt=1)128        self.assertTrue(expNode2 in nodes)129        self.assertTrue(expNode3 in nodes)130        self.assertTrue(self.buildDefaultPkgNode() in nodes)131    def testAppendLocationInfo(self):132        self.verifyAppendLocationInfo(self.cases, self.key, self.toParse, self.location)133class TestCommandsTest(RootTest):134    def setUp(self):135        self.commands = TestCommands()136        self.key = "FooTest.testFoo()"137        self.toParse = ["TestCommand", self.key, "FooTest.java", "10", "FooTest", "4"]138        self.expNode = Node(name=self.key, color="black", label="testFoo()", \139                            entity="testcommand", style=2, isSrcEnt=1)140    def testParse(self):141        location = ("FooTest.java", 10)142        self.verifyParse(self.commands, self.toParse, self.key, location)143        self.assertEquals("FooTest", self.commands.getOwner(self.key))144    def testParseMulti(self):145        location = ("FooTest.java", 10)146        self.verifyParse(self.commands, self.toParse, self.key, location)147        148        toParse2 = ["TestCommand", "BazTest.tesBaz()", "BazTest.java", "15", "BazTest", "8"]149        key2 = "BazTest.tesBaz()"150        location2 = ("BazTest.java", 15)151        self.verifyParse(self.commands, toParse2, key2, location2)152        self.assertTrue(self.commands.hasKey(self.key))153        self.assertEquals(location, self.commands.getLocation(self.key))154        self.assertEquals("FooTest", self.commands.getOwner(self.key))155        self.assertEquals("BazTest", self.commands.getOwner(key2))156    def testGenerateNodes(self):157        self.verifyGenerateNodes(self.commands, self.expNode)158class TestHelpersTest(RootTest):159    def setUp(self):160        self.helpers = TestHelpers()161        162    def testParse(self):163        toParse = ["TestHelper", "FooTest.helper()", "FooTest.java", "15", "FooTest", "4"]164        key = "FooTest.helper()"165        location = ("FooTest.java", 15)166        self.verifyParse(self.helpers, toParse, key, location)167        self.assertEquals("FooTest", self.helpers.getOwner(key))168    def testParseParams(self):169        toParse = ["TestHelper", "FooTest.construct(String,Integer)", "FooTest.java", "15", "FooTest", "11"]170        key = "FooTest.construct(String;Integer)"171        location = ("FooTest.java", 15)172        self.verifyParse(self.helpers, toParse, key, location)173        self.assertEquals("FooTest", self.helpers.getOwner(key))174class TestSetupsTest(RootTest):175    def setUp(self):176        self.setups = TestSetups()177    def testParse(self):178        toParse = ["TestSetup", "FooTest.setUp()", "FooTest.java", "15", "FooTest", "15"]179        key = "FooTest.setUp()"180        location = ("FooTest.java", 15)181        self.verifyParse(self.setups, toParse, key, location)182        self.assertEquals("FooTest", self.setups.getOwner(key))183class TestTeardownsTest(RootTest):184    def setUp(self):185        self.teardowns = TestTeardowns()186    def testParse(self):187        toParse = ["TestTeardown", "FooTest.tearDown()", "FooTest.java", "15", "FooTest", "12"]188        key = "FooTest.tearDown()"189        location = ("FooTest.java", 15)190        self.verifyParse(self.teardowns, toParse, key, location)191        self.assertEquals("FooTest", self.teardowns.getOwner(key))192class AssertionLesssTest(RootTest):193    def setUp(self):194        self.assertionlesss = AssertionLesss()195        self.key = "FooTest.testFoo()"        196        self.toParse = ["AssertionLess", self.key, "FooTest.java", "25"]197        self.expNode = Node(name="AssertionLess0", color=SMELL_NODE_COLOR,\198                             label="AssertionLess", entity="smell", \199                            style=3)200    def testParse(self):201        location = ("FooTest.java", 25)202        self.verifyParse(self.assertionlesss, self.toParse, self.key, location)203    def testGenerateNodes(self):204        self.verifyGenerateNodes(self.assertionlesss, self.expNode)205class AssertionRoulettesTest(RootTest):206    def setUp(self):207        self.assertionroulettes = AssertionRoulettes()208        self.AR = 'AssertionRoulette'209        self.toParse = [ self.AR , "TC", "FooTest.testFoo()", "10", "8", "FooTest.java", "228"]210        211    def testParse(self):212        key = "FooTest.testFoo()"213        location = ("FooTest.java", 228)214        self.verifyParse(self.assertionroulettes, self.toParse, key, location)215        self.assertEquals(10, self.assertionroulettes.getTotalAsserts(key))216        self.assertEquals(8, self.assertionroulettes.getDescriptionlessAsserts(key))217    def testAppendMetrics(self):218        self.verifyAppendMetricsInfo(self.assertionroulettes, self.AR, self.toParse, [('NrA', 10),('NrDA', 8)])219    def testAppendMultiMetrics(self):220        self.assertionroulettes.parse(self.toParse)221        self.toParse2 = [ self.AR, "TH", "BarTest.testBar()", "15", "5", "BarTest.java", "220"]222        self.assertionroulettes.parse(self.toParse)223        self.assertionroulettes.parse(self.toParse2)224        metricDict = self.setupMetricDict()225        self.assertionroulettes.appendMetricInfo(metricDict)226        self.assertTrue(self.AR in metricDict)227        metrics = metricDict[self.AR]228        self.assertEquals(2, len(metrics), str(metrics))229        self.assertEquals({'NrA':10, 'NrDA':8}, metrics[self.AR + '0'])230        self.assertEquals({'NrA':15, 'NrDA':5}, metrics[self.AR + '1'])231class DuplicatedCodesTest(TestCase):232    def setUp(self):233        # GeneralFixture :))234        self.DP = "DuplicatedCode"235        self.duplicatedcodes = DuplicatedCodes()236        self.mtd1 = "BtPieceMessageTest.testChokingEvent_inAmAllowedIndexSet()"237        self.mtd2 = "BtPieceMessageTest.testChokingEvent_somwhere()"238        self.dupLoc1 = ("BtPieceMessageTest.cc", 197, 206)239        self.dupLoc2 = ("BtPieceMessageTest.cc", 183, 193)240        self.toParse = ["DuplicatedCode",\241                    self.mtd1, "BtPieceMessageTest.cc", "197", "206", 242                    self.mtd2, "BtPieceMessageTest.cc", "183", "193"]243        self.mtd21 = "Faz.testFaz()"244        self.mtd22 = "Boo.testBoo()"245        self.dupLoc21 = ("Faz.cpp", 20, 25)246        self.dupLoc22 = ("Boo.cpp", 30, 35)247        self.toParse2 = ["DuplicatedCode",\248                    self.mtd21, "Faz.cpp", 20, 25,\249                    self.mtd22, "Boo.cpp", 30, 35]250    def testParse(self):251        self.duplicatedcodes.parse(self.toParse)252        self.assertEquals(1, len(self.duplicatedcodes.duplicates))253    def testParseMulti(self):254        self.duplicatedcodes.parse(self.toParse)255        self.duplicatedcodes.parse(self.toParse2)256        self.assertEquals(2, len(self.duplicatedcodes.duplicates))257    def testAppendLocationInfo(self):258        self.duplicatedcodes.parse(self.toParse)259        locInfo = {}260        self.duplicatedcodes.appendLocationInfo(locInfo)261        self.assertEqual(1, len(locInfo), "Should have a single entry")262        self.assertTrue("DuplicatedCode0" in locInfo)263        entry = locInfo["DuplicatedCode0"]264        self.assertEqual(2, len(entry))265        self.assertTrue(self.dupLoc1 in entry)266        self.assertTrue(self.dupLoc2 in entry)267    def testAppendLocationInfoQuad(self):268        self.mtd3 = "FooTest.testFoo()"269        self.dupLoc3 = ("FooTest.cpp", 20, 25)270        self.mtd4 = "BazTest.testBaz()"271        self.dupLoc4 = ("BazTest.cpp", 30, 35)272        self.toParse.extend([self.mtd3, "FooTest.cpp", 20, 25,\273                             self.mtd4, "BazTest.cpp", 30, 35])274        self.duplicatedcodes.parse(self.toParse)275        locInfo = {}276        self.duplicatedcodes.appendLocationInfo(locInfo)277        self.assertEqual(1, len(locInfo))278        self.assertTrue("DuplicatedCode0" in locInfo)279        entry = locInfo["DuplicatedCode0"]280        self.assertEqual(4, len(entry))281        self.assertTrue(self.dupLoc1 in entry)282        self.assertTrue(self.dupLoc2 in entry)283        self.assertTrue(self.dupLoc3 in entry)284        self.assertTrue(self.dupLoc4 in entry)285    def testAppendLocationInfo2Nodes(self):286        self.duplicatedcodes.parse(self.toParse)287        self.duplicatedcodes.parse(self.toParse2)288        locInfo = {}289        self.duplicatedcodes.appendLocationInfo(locInfo)290        self.assertEquals(2, len(locInfo))291        entry0 = locInfo["DuplicatedCode0"]292        entry1 = locInfo["DuplicatedCode1"]293        self.assertEqual(2, len(entry0), "Should be a two-way duplicate")294        self.assertTrue(self.dupLoc1 in entry0)295        self.assertTrue(self.dupLoc2 in entry0)296        self.assertEqual(2, len(entry1), "Should be a two-way duplicate")297        self.assertTrue(self.dupLoc21 in entry1)298        self.assertTrue(self.dupLoc22 in entry1)299    def setUpEdges(self):300        self.edge1 = Edge(self.mtd1, "DuplicatedCode0")301        self.edge2 = Edge(self.mtd2, "DuplicatedCode0")302    def testGenerateEdgesSingleMtd(self):303        self.setUpEdges()304        self.toParse[5] = self.mtd1305        self.duplicatedcodes.parse(self.toParse)306        edges = self.duplicatedcodes.generateEdges()307        self.assertEqual(1, len(edges))308        self.assertTrue(self.edge1 in edges)309    def testGenerateEdgesMultiMtd(self):310        self.setUpEdges()311        self.duplicatedcodes.parse(self.toParse)312        edges = self.duplicatedcodes.generateEdges()313 314        self.assertEqual(2, len(edges))315        self.assertTrue(self.edge1 in edges,\316                        str(self.edge1) + "should be in" +str([str(edge) for edge in edges]))317        self.assertTrue(self.edge2 in edges)318    def testCalculateANrSLSingle(self):319        self.dupli = [self.DP, "Foo.foo()", "Foo.java", 2, 10]320        ANrSL = self.duplicatedcodes.calculateANrSL(self.dupli)321        self.assertEquals(ANrSL, 9)322    def testCalculateANrSLDuo(self):323        self.dupli = [self.DP, "Foo.foo()", "Foo.java", 2, 10, \324                               "Bar.bar()", "Bar.java", 10, 18]325        ANrSL = self.duplicatedcodes.calculateANrSL(self.dupli)326        self.assertEquals(ANrSL, 9)327        self.dupli = [self.DP, "Foo.foo()", "Foo.java", 2, 10, \328                               "Bar.bar()", "Bar.java", 10, 16]329        ANrSL = self.duplicatedcodes.calculateANrSL(self.dupli)330        self.assertEquals(ANrSL, 8)331    def testCalculateANrSLTriple(self):332        self.dupli = [self.DP, "Foo.foo()", "Foo.java", 2, 10, \333                               "Bar.bar()", "Bar.java", 10, 16, \334                               "Baz.baz()", "Baz.java", 16, 20]335        ANrSL = self.duplicatedcodes.calculateANrSL(self.dupli)336        self.assertEquals(ANrSL, 7)337    def testAppendMetricInfo(self):338        self.duplicatedcodes.parse(self.toParse)339        metricDict = {}340        metricDict['Translation'] = {}341        self.duplicatedcodes.appendMetricInfo(metricDict)342        self.assertTrue(self.DP in metricDict)343        metrics = metricDict[self.DP]344        self.assertEquals(1, len(metrics), \345                        "Should contain a single duplicated code metric dict")346        self.assertTrue(self.DP + "0" in metrics)347        metrics = metrics[self.DP + "0"]348        val = self.duplicatedcodes.calculateANrSL(self.toParse)349        self.assertEquals(val, metrics['ANrSL'])350class ForTestersOnlysTest(RootTest):351    def setUp(self):352        self.fortestersonlys = ForTestersOnlys()353    def testParse(self):354        toParse = ["ForTestersOnly","Request.getReferer()","Request.h","111"]355        key = "Request.getReferer()"356        location = ("Request.h", 111)357        self.verifyParse(self.fortestersonlys, toParse, key, location)358class IndentedTestsTest(RootTest):359    def setUp(self):360        self.indentedtests = IndentedTests()361        self.IT = "IndentedTest"362        self.key = "FileTest.testRemove()"363        self.toParse = ["IndentedTest","TC",self.key,"1","FileTest.cc","78"]364        self.location = ("FileTest.cc", 78)365    def testParse(self):366        self.verifyParse(self.indentedtests, self.toParse, self.key, self.location)367        self.assertEquals("TC", self.indentedtests.getType(self.key))368        self.assertEquals(1, self.indentedtests.getCount(self.key))369    def testGenerateNodes(self):370        self.expNode = Node(name="IndentedTest0", color=SMELL_NODE_COLOR, \371                            entity="smell", label="IndentedTest", style=3)372        self.verifyGenerateNodes(self.indentedtests, self.expNode)373    def testGenerateEdges(self):374        self.indentedtests.parse(self.toParse)375        edges = self.indentedtests.generateEdges()376        self.expEdge = Edge(node1=self.key, node2="IndentedTest0")377        self.assertEquals(1, len(edges))378        self.assertTrue(self.expEdge in edges,\379            str(self.expEdge) + " should be in " + str([str(edge) for edge in edges]))380    def testAppendLocationInfo(self):381        self.verifyAppendLocationInfo(self.indentedtests, "IndentedTest0", self.toParse, self.location)382    def testAppendMetricsInfo(self):383        self.verifyAppendMetricsInfo(self.indentedtests, self.IT, self.toParse, [('NrCS', 1)])384class IndirectTestsTest(RootTest):385    def setUp(self):386        self.indirecttests = IndirectTests()387        self.toParse = ["IndirectTest","BtDependencyTest.testResolve()","4","5","BtDependencyTest.cc","57"]388    def testParse(self):389        key = "BtDependencyTest.testResolve()"390        location = ("BtDependencyTest.cc", 57)391        self.verifyParse(self.indirecttests, self.toParse, key, location)392        self.assertEquals(4, self.indirecttests.getTreshold(key))393        self.assertEquals(5, self.indirecttests.getNPTU(key))394    def testAppendMetricsInfo(self):395        self.verifyAppendMetricsInfo(self.indirecttests, 'IndirectTest', self.toParse, [('NPTU', 5)])396class EagerTestsTest(RootTest):397    def setUp(self):398        self.eagertests = EagerTests()399        self.toParse = ["EagerTest","FooTest.testFoo()", "5", "6","FooTest.java","89"]400        self.location = ("FooTest.java", 89)401    def testParse(self):402        key = "FooTest.testFoo()"403        self.verifyParse(self.eagertests, self.toParse, key, self.location)404        self.assertEquals(5, self.eagertests.getTreshold(key))405        self.assertEquals(6, self.eagertests.getPTMI(key))406    def setupExpNode(self):407        self.expNode = Node(name="EagerTest0", color=SMELL_NODE_COLOR, \408                            entity="smell", label="EagerTest", style=3)409    def testGenerateNodes(self):410        self.setupExpNode()411        self.verifyGenerateNodes(self.eagertests, self.expNode)412    def testGenerateMultiNodes(self):413        self.setupExpNode()414        self.toParse2 = ["EagerTest","FuuTest.testFuu()", "5", "8","FuuTest.java","90"]415        self.expNode2 = Node(name="EagerTest1", color=SMELL_NODE_COLOR,\416                            entity="smell", label="EagerTest", style=3)417        self.verifyGenerateMultiNodes(self.eagertests, self.expNode, self.expNode2, self.toParse, self.toParse2)418    def testAppendLocationInfo(self):419        self.verifyAppendLocationInfo(self.eagertests, "EagerTest0", self.toParse, self.location)420    def testAppendMetricsInfo(self):421        self.verifyAppendMetricsInfo(self.eagertests, 'EagerTest', self.toParse, [('PTMI', 6)])422class SensitiveEqualitysTest(RootTest):423    def setUp(self):424        self.sensitiveequalitys = SensitiveEqualitys()425        self.toParse = ["SensitiveEquality", "TC", "BtInterestedMessageTest.testToString()", "1", "BtInterestedMessageTest.cc", "27"]426    427    def testParse(self):428        key = "BtInterestedMessageTest.testToString()"429        location = ("BtInterestedMessageTest.cc", 27)430        self.verifyParse(self.sensitiveequalitys, self.toParse, key, location)431        self.assertEquals(1, self.sensitiveequalitys.getCount(key))432        self.assertEquals("TC", self.sensitiveequalitys.getType(key))433    def testAppendMetricInfo(self):434        self.verifyAppendMetricsInfo(self.sensitiveequalitys, "SensitiveEquality", self.toParse, [('NrTS', 1)])435    def testAppendMetricInfo2(self):436        self.toParse[3] = "10"437        self.verifyAppendMetricsInfo(self.sensitiveequalitys, "SensitiveEquality", self.toParse, [('NrTS', 10)])438class GeneralFixturesTest(RootTest):439    def setUp(self):440        self.generalfixtures = GeneralFixtures()441        self.toParse = ["GeneralFixture","DefaultPackageTest",442                        "5","6","10","DefaultPackageTest.java","0"]443        444    def testParse(self):445        self.key = "DefaultPackageTest"446        self.location = ("DefaultPackageTest.java", 0)447        self.verifyParse(self.generalfixtures, self.toParse, self.key, self.location)448        self.assertEquals(5, self.generalfixtures.getNFOB(self.key))449        self.assertEquals(6, self.generalfixtures.getNFPT(self.key))450        self.assertEquals(10, self.generalfixtures.getNOBU(self.key))451    def testAppendMetricInfo(self):452        self.verifyAppendMetricsInfo(self.generalfixtures, "GeneralFixture", self.toParse, \453                                     [('NFOB', 5), ('NFPT', 6), ('NOBU', 10)])454    def testAppendMetricInfo2(self):455        self.toParse[2] = "8"456        self.toParse[3] = "3"457        self.toParse[4] = "20"458        self.verifyAppendMetricsInfo(self.generalfixtures, "GeneralFixture", self.toParse, \459                                     [('NFOB', 8), ('NFPT', 3), ('NOBU', 20)])460class MysteryGuestsTest(TestCase):461    def setUp(self):462        self.mysteryguests = MysteryGuests()463        self.command = "MysteryTest.testSomething()"464        self.commandLocation = ("MysteryTest.java", 5)465        self.target = "MyOtherProductionClass.myOtherMethod(String)"466        self.targetLocation = ("MyOtherProductionClass.java",6)467        self.toParse=["MysteryGuest", self.command , "MysteryTest.java", "5",\468                     self.target, "MyOtherProductionClass.java","6","file",\469                     "java::io::BufferedReader.readLine()"]470    def testParse(self):471        self.mysteryguests.parse(self.toParse)472    def testAppendLocationInfo(self):473        self.mysteryguests.parse(self.toParse)474        srcDict = {}475        self.mysteryguests.appendLocationInfo(srcDict)476        self.assertEquals(1, len(srcDict))477        self.assertTrue("MysteryGuest0" in srcDict)478        self.assertTrue(2, srcDict["MysteryGuest0"])479        val = srcDict["MysteryGuest0"]480        self.assertTrue(self.commandLocation in val)481        self.assertTrue(self.targetLocation in val)482    #def testGenLocationDirectMystery(self):483        #toParse = self.toParse484        #toParse[4] = self.command485        #toParse[5] = self.commandLocation[0]486        #toParse[6] = str(self.commandLocation[1])487        #self.mysteryguests.parse(toParse)488        #locations = self.mysteryguests.generateLocationNodes()489        #self.assertEqual(1, len(locations))490        #self.assertTrue(self.expCmdLocation in locations)491    #def testGenLocationComma(self):492        #toParse = self.toParse493        #toParse[1] = "MysteryTest.someHelper(String,Integer)"494        #self.mysteryguests.parse(toParse)495        #locations = self.mysteryguests.generateLocationNodes()496        #expLocation = LocationNode("srcloc_MysteryTest.someHelper(String;Integer)", self.commandLocation)497        #self.assertEquals(2, len(locations))498        #print locations[0]499        #print expLocation500        #self.assertTrue(expLocation in locations)501class NodeTest(TestCase):502    def testConstructor(self):503        node = Node(name="TestFoo", color="black", entity="testcase", label="TestFoo", style=1)504        self.assertEquals("TestFoo", node.name)505        self.assertEquals("black", node.color)506        self.assertEquals("testcase", node.entity)507        self.assertEquals("TestFoo", node.label)508        self.assertEquals("1", node.style)...

Full Screen

Full Screen

command_parser_test.py

Source:command_parser_test.py Github

copy

Full Screen

1# Copyright 2016 The TensorFlow Authors. All Rights Reserved.2#3# Licensed under the Apache License, Version 2.0 (the "License");4# you may not use this file except in compliance with the License.5# You may obtain a copy of the License at6#7#     http://www.apache.org/licenses/LICENSE-2.08#9# Unless required by applicable law or agreed to in writing, software10# distributed under the License is distributed on an "AS IS" BASIS,11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.12# See the License for the specific language governing permissions and13# limitations under the License.14# ==============================================================================15"""Tests for TensorFlow Debugger command parser."""16from __future__ import absolute_import17from __future__ import division18from __future__ import print_function19import sys20from tensorflow.python.debug.cli import command_parser21from tensorflow.python.framework import test_util22from tensorflow.python.platform import googletest23class ParseCommandTest(test_util.TensorFlowTestCase):24  def testParseNoBracketsOrQuotes(self):25    command = ""26    self.assertEqual([], command_parser.parse_command(command))27    command = "a"28    self.assertEqual(["a"], command_parser.parse_command(command))29    command = "foo bar baz qux"30    self.assertEqual(["foo", "bar", "baz", "qux"],31                     command_parser.parse_command(command))32    command = "foo bar\tbaz\t qux"33    self.assertEqual(["foo", "bar", "baz", "qux"],34                     command_parser.parse_command(command))35  def testParseLeadingTrailingWhitespaces(self):36    command = "  foo bar baz qux   "37    self.assertEqual(["foo", "bar", "baz", "qux"],38                     command_parser.parse_command(command))39    command = "\nfoo bar baz qux\n"40    self.assertEqual(["foo", "bar", "baz", "qux"],41                     command_parser.parse_command(command))42  def testParseCommandsWithBrackets(self):43    command = "pt foo[1, 2, :]"44    self.assertEqual(["pt", "foo[1, 2, :]"],45                     command_parser.parse_command(command))46    command = "pt  foo[1, 2, :]   -a"47    self.assertEqual(["pt", "foo[1, 2, :]", "-a"],48                     command_parser.parse_command(command))49    command = "inject_value foo [1, 2,:] 0"50    self.assertEqual(["inject_value", "foo", "[1, 2,:]", "0"],51                     command_parser.parse_command(command))52  def testParseCommandWithTwoArgsContainingBrackets(self):53    command = "pt foo[1, :] bar[:, 2]"54    self.assertEqual(["pt", "foo[1, :]", "bar[:, 2]"],55                     command_parser.parse_command(command))56    command = "pt foo[] bar[:, 2]"57    self.assertEqual(["pt", "foo[]", "bar[:, 2]"],58                     command_parser.parse_command(command))59  def testParseCommandWithUnmatchedBracket(self):60    command = "pt  foo[1, 2, :"61    self.assertNotEqual(["pt", "foo[1, 2, :]"],62                        command_parser.parse_command(command))63  def testParseCommandsWithQuotes(self):64    command = "inject_value foo \"np.zeros([100, 500])\""65    self.assertEqual(["inject_value", "foo", "np.zeros([100, 500])"],66                     command_parser.parse_command(command))67    # The pair of double quotes should have been stripped.68    command = "inject_value foo 'np.zeros([100, 500])'"69    self.assertEqual(["inject_value", "foo", "np.zeros([100, 500])"],70                     command_parser.parse_command(command))71    # The pair of single quotes should have been stripped.72    command = "\"command prefix with spaces\" arg1"73    self.assertEqual(["command prefix with spaces", "arg1"],74                     command_parser.parse_command(command))75  def testParseCommandWithTwoArgsContainingQuotes(self):76    command = "foo \"bar\" \"qux\""77    self.assertEqual(["foo", "bar", "qux"],78                     command_parser.parse_command(command))79    command = "foo \"\" \"qux\""80    self.assertEqual(["foo", "", "qux"],81                     command_parser.parse_command(command))82class ExtractOutputFilePathTest(test_util.TensorFlowTestCase):83  def testNoOutputFilePathIsReflected(self):84    args, output_path = command_parser.extract_output_file_path(["pt", "a:0"])85    self.assertEqual(["pt", "a:0"], args)86    self.assertIsNone(output_path)87  def testHasOutputFilePathInOneArgsIsReflected(self):88    args, output_path = command_parser.extract_output_file_path(89        ["pt", "a:0", ">/tmp/foo.txt"])90    self.assertEqual(["pt", "a:0"], args)91    self.assertEqual(output_path, "/tmp/foo.txt")92  def testHasOutputFilePathInTwoArgsIsReflected(self):93    args, output_path = command_parser.extract_output_file_path(94        ["pt", "a:0", ">", "/tmp/foo.txt"])95    self.assertEqual(["pt", "a:0"], args)96    self.assertEqual(output_path, "/tmp/foo.txt")97  def testHasGreaterThanSignButNoFileNameCausesSyntaxError(self):98    with self.assertRaisesRegexp(SyntaxError, "Redirect file path is empty"):99      command_parser.extract_output_file_path(100          ["pt", "a:0", ">"])101  def testOutputPathMergedWithLastArgIsHandledCorrectly(self):102    args, output_path = command_parser.extract_output_file_path(103        ["pt", "a:0>/tmp/foo.txt"])104    self.assertEqual(["pt", "a:0"], args)105    self.assertEqual(output_path, "/tmp/foo.txt")106  def testOutputPathInLastArgGreaterThanInSecondLastIsHandledCorrectly(self):107    args, output_path = command_parser.extract_output_file_path(108        ["pt", "a:0>", "/tmp/foo.txt"])109    self.assertEqual(["pt", "a:0"], args)110    self.assertEqual(output_path, "/tmp/foo.txt")111  def testFlagWithEqualGreaterThanShouldIgnoreIntervalFlags(self):112    args, output_path = command_parser.extract_output_file_path(113        ["lp", "--execution_time=>100ms"])114    self.assertEqual(["lp", "--execution_time=>100ms"], args)115    self.assertIsNone(output_path)116    args, output_path = command_parser.extract_output_file_path(117        ["lp", "--execution_time", ">1.2s"])118    self.assertEqual(["lp", "--execution_time", ">1.2s"], args)119    self.assertIsNone(output_path)120    args, output_path = command_parser.extract_output_file_path(121        ["lp", "-e", ">1200"])122    self.assertEqual(["lp", "-e", ">1200"], args)123    self.assertIsNone(output_path)124    args, output_path = command_parser.extract_output_file_path(125        ["lp", "--foo_value", ">-.2MB"])126    self.assertEqual(["lp", "--foo_value", ">-.2MB"], args)127    self.assertIsNone(output_path)128    args, output_path = command_parser.extract_output_file_path(129        ["lp", "--bar_value", ">-42e3GB"])130    self.assertEqual(["lp", "--bar_value", ">-42e3GB"], args)131    self.assertIsNone(output_path)132    args, output_path = command_parser.extract_output_file_path(133        ["lp", "--execution_time", ">=100ms"])134    self.assertEqual(["lp", "--execution_time", ">=100ms"], args)135    self.assertIsNone(output_path)136    args, output_path = command_parser.extract_output_file_path(137        ["lp", "--execution_time=>=100ms"])138    self.assertEqual(["lp", "--execution_time=>=100ms"], args)139    self.assertIsNone(output_path)140  def testFlagWithEqualGreaterThanShouldRecognizeFilePaths(self):141    args, output_path = command_parser.extract_output_file_path(142        ["lp", ">1.2s"])143    self.assertEqual(["lp"], args)144    self.assertEqual("1.2s", output_path)145    args, output_path = command_parser.extract_output_file_path(146        ["lp", "--execution_time", ">x.yms"])147    self.assertEqual(["lp", "--execution_time"], args)148    self.assertEqual("x.yms", output_path)149    args, output_path = command_parser.extract_output_file_path(150        ["lp", "--memory", ">a.1kB"])151    self.assertEqual(["lp", "--memory"], args)152    self.assertEqual("a.1kB", output_path)153    args, output_path = command_parser.extract_output_file_path(154        ["lp", "--memory", ">e002MB"])155    self.assertEqual(["lp", "--memory"], args)156    self.assertEqual("e002MB", output_path)157  def testOneArgumentIsHandledCorrectly(self):158    args, output_path = command_parser.extract_output_file_path(["lt"])159    self.assertEqual(["lt"], args)160    self.assertIsNone(output_path)161  def testEmptyArgumentIsHandledCorrectly(self):162    args, output_path = command_parser.extract_output_file_path([])163    self.assertEqual([], args)164    self.assertIsNone(output_path)165class ParseTensorNameTest(test_util.TensorFlowTestCase):166  def testParseTensorNameWithoutSlicing(self):167    (tensor_name,168     tensor_slicing) = command_parser.parse_tensor_name_with_slicing(169         "hidden/weights/Variable:0")170    self.assertEqual("hidden/weights/Variable:0", tensor_name)171    self.assertEqual("", tensor_slicing)172  def testParseTensorNameWithSlicing(self):173    (tensor_name,174     tensor_slicing) = command_parser.parse_tensor_name_with_slicing(175         "hidden/weights/Variable:0[:, 1]")176    self.assertEqual("hidden/weights/Variable:0", tensor_name)177    self.assertEqual("[:, 1]", tensor_slicing)178class ValidateSlicingStringTest(test_util.TensorFlowTestCase):179  def testValidateValidSlicingStrings(self):180    self.assertTrue(command_parser.validate_slicing_string("[1]"))181    self.assertTrue(command_parser.validate_slicing_string("[2,3]"))182    self.assertTrue(command_parser.validate_slicing_string("[4, 5, 6]"))183    self.assertTrue(command_parser.validate_slicing_string("[7,:, :]"))184  def testValidateInvalidSlicingStrings(self):185    self.assertFalse(command_parser.validate_slicing_string(""))186    self.assertFalse(command_parser.validate_slicing_string("[1,"))187    self.assertFalse(command_parser.validate_slicing_string("2,3]"))188    self.assertFalse(command_parser.validate_slicing_string("[4, foo()]"))189    self.assertFalse(command_parser.validate_slicing_string("[5, bar]"))190class ParseIndicesTest(test_util.TensorFlowTestCase):191  def testParseValidIndicesStringsWithBrackets(self):192    self.assertEqual([0], command_parser.parse_indices("[0]"))193    self.assertEqual([0], command_parser.parse_indices(" [0] "))194    self.assertEqual([-1, 2], command_parser.parse_indices("[-1, 2]"))195    self.assertEqual([3, 4, -5],196                     command_parser.parse_indices("[3,4,-5]"))197  def testParseValidIndicesStringsWithoutBrackets(self):198    self.assertEqual([0], command_parser.parse_indices("0"))199    self.assertEqual([0], command_parser.parse_indices(" 0 "))200    self.assertEqual([-1, 2], command_parser.parse_indices("-1, 2"))201    self.assertEqual([3, 4, -5], command_parser.parse_indices("3,4,-5"))202  def testParseInvalidIndicesStringsWithoutBrackets(self):203    with self.assertRaisesRegexp(204        ValueError, r"invalid literal for int\(\) with base 10: 'a'"):205      self.assertEqual([0], command_parser.parse_indices("0,a"))206    with self.assertRaisesRegexp(207        ValueError, r"invalid literal for int\(\) with base 10: '2\]'"):208      self.assertEqual([0], command_parser.parse_indices("1, 2]"))209    with self.assertRaisesRegexp(210        ValueError, r"invalid literal for int\(\) with base 10: ''"):211      self.assertEqual([0], command_parser.parse_indices("3, 4,"))212class ParseRangesTest(test_util.TensorFlowTestCase):213  INF_VALUE = sys.float_info.max214  def testParseEmptyRangeString(self):215    self.assertEqual([], command_parser.parse_ranges(""))216    self.assertEqual([], command_parser.parse_ranges("  "))217  def testParseSingleRange(self):218    self.assertAllClose([[-0.1, 0.2]],219                        command_parser.parse_ranges("[-0.1, 0.2]"))220    self.assertAllClose([[-0.1, self.INF_VALUE]],221                        command_parser.parse_ranges("[-0.1, inf]"))222    self.assertAllClose([[-self.INF_VALUE, self.INF_VALUE]],223                        command_parser.parse_ranges("[-inf, inf]"))224  def testParseSingleListOfRanges(self):225    self.assertAllClose([[-0.1, 0.2], [10.0, 12.0]],226                        command_parser.parse_ranges("[[-0.1, 0.2], [10,  12]]"))227    self.assertAllClose(228        [[-self.INF_VALUE, -1.0], [1.0, self.INF_VALUE]],229        command_parser.parse_ranges("[[-inf, -1.0],[1.0, inf]]"))230  def testParseInvalidRangeString(self):231    with self.assertRaises(SyntaxError):232      command_parser.parse_ranges("[[1,2]")233    with self.assertRaisesRegexp(ValueError,234                                 "Incorrect number of elements in range"):235      command_parser.parse_ranges("[1,2,3]")236    with self.assertRaisesRegexp(ValueError,237                                 "Incorrect number of elements in range"):238      command_parser.parse_ranges("[inf]")239    with self.assertRaisesRegexp(ValueError,240                                 "Incorrect type in the 1st element of range"):241      command_parser.parse_ranges("[1j, 1]")242    with self.assertRaisesRegexp(ValueError,243                                 "Incorrect type in the 2nd element of range"):244      command_parser.parse_ranges("[1, 1j]")245class ParseReadableSizeStrTest(test_util.TensorFlowTestCase):246  def testParseNoUnitWorks(self):247    self.assertEqual(0, command_parser.parse_readable_size_str("0"))248    self.assertEqual(1024, command_parser.parse_readable_size_str("1024 "))249    self.assertEqual(2000, command_parser.parse_readable_size_str(" 2000 "))250  def testParseKiloBytesWorks(self):251    self.assertEqual(0, command_parser.parse_readable_size_str("0kB"))252    self.assertEqual(1024**2, command_parser.parse_readable_size_str("1024 kB"))253    self.assertEqual(1024**2 * 2,254                     command_parser.parse_readable_size_str("2048k"))255    self.assertEqual(1024**2 * 2,256                     command_parser.parse_readable_size_str("2048kB"))257    self.assertEqual(1024 / 4, command_parser.parse_readable_size_str("0.25k"))258  def testParseMegaBytesWorks(self):259    self.assertEqual(0, command_parser.parse_readable_size_str("0MB"))260    self.assertEqual(1024**3, command_parser.parse_readable_size_str("1024 MB"))261    self.assertEqual(1024**3 * 2,262                     command_parser.parse_readable_size_str("2048M"))263    self.assertEqual(1024**3 * 2,264                     command_parser.parse_readable_size_str("2048MB"))265    self.assertEqual(1024**2 / 4,266                     command_parser.parse_readable_size_str("0.25M"))267  def testParseGigaBytesWorks(self):268    self.assertEqual(0, command_parser.parse_readable_size_str("0GB"))269    self.assertEqual(1024**4, command_parser.parse_readable_size_str("1024 GB"))270    self.assertEqual(1024**4 * 2,271                     command_parser.parse_readable_size_str("2048G"))272    self.assertEqual(1024**4 * 2,273                     command_parser.parse_readable_size_str("2048GB"))274    self.assertEqual(1024**3 / 4,275                     command_parser.parse_readable_size_str("0.25G"))276  def testParseUnsupportedUnitRaisesException(self):277    with self.assertRaisesRegexp(278        ValueError, "Failed to parsed human-readable byte size str: \"0foo\""):279      command_parser.parse_readable_size_str("0foo")280    with self.assertRaisesRegexp(281        ValueError, "Failed to parsed human-readable byte size str: \"2E\""):282      command_parser.parse_readable_size_str("2EB")283class ParseReadableTimeStrTest(test_util.TensorFlowTestCase):284  def testParseNoUnitWorks(self):285    self.assertEqual(0, command_parser.parse_readable_time_str("0"))286    self.assertEqual(100, command_parser.parse_readable_time_str("100 "))287    self.assertEqual(25, command_parser.parse_readable_time_str(" 25 "))288  def testParseSeconds(self):289    self.assertEqual(1e6, command_parser.parse_readable_time_str("1 s"))290    self.assertEqual(2e6, command_parser.parse_readable_time_str("2s"))291  def testParseMicros(self):292    self.assertEqual(2, command_parser.parse_readable_time_str("2us"))293  def testParseMillis(self):294    self.assertEqual(2e3, command_parser.parse_readable_time_str("2ms"))295  def testParseUnsupportedUnitRaisesException(self):296    with self.assertRaisesRegexp(297        ValueError, r".*float.*2us.*"):298      command_parser.parse_readable_time_str("2uss")299    with self.assertRaisesRegexp(300        ValueError, r".*float.*2m.*"):301      command_parser.parse_readable_time_str("2m")302    with self.assertRaisesRegexp(303        ValueError, r"Invalid time -1. Time value must be positive."):304      command_parser.parse_readable_time_str("-1s")305class ParseInterval(test_util.TensorFlowTestCase):306  def testParseTimeInterval(self):307    self.assertEquals(308        command_parser.Interval(10, True, 1e3, True),309        command_parser.parse_time_interval("[10us, 1ms]"))310    self.assertEquals(311        command_parser.Interval(10, False, 1e3, False),312        command_parser.parse_time_interval("(10us, 1ms)"))313    self.assertEquals(314        command_parser.Interval(10, False, 1e3, True),315        command_parser.parse_time_interval("(10us, 1ms]"))316    self.assertEquals(317        command_parser.Interval(10, True, 1e3, False),318        command_parser.parse_time_interval("[10us, 1ms)"))319    self.assertEquals(command_parser.Interval(0, False, 1e3, True),320                      command_parser.parse_time_interval("<=1ms"))321    self.assertEquals(322        command_parser.Interval(1e3, True, float("inf"), False),323        command_parser.parse_time_interval(">=1ms"))324    self.assertEquals(command_parser.Interval(0, False, 1e3, False),325                      command_parser.parse_time_interval("<1ms"))326    self.assertEquals(327        command_parser.Interval(1e3, False, float("inf"), False),328        command_parser.parse_time_interval(">1ms"))329  def testParseTimeGreaterLessThanWithInvalidValueStrings(self):330    with self.assertRaisesRegexp(ValueError, "Invalid value string after >= "):331      command_parser.parse_time_interval(">=wms")332    with self.assertRaisesRegexp(ValueError, "Invalid value string after > "):333      command_parser.parse_time_interval(">Yms")334    with self.assertRaisesRegexp(ValueError, "Invalid value string after <= "):335      command_parser.parse_time_interval("<= _ms")336    with self.assertRaisesRegexp(ValueError, "Invalid value string after < "):337      command_parser.parse_time_interval("<-ms")338  def testParseTimeIntervalsWithInvalidValueStrings(self):339    with self.assertRaisesRegexp(ValueError, "Invalid first item in interval:"):340      command_parser.parse_time_interval("[wms, 10ms]")341    with self.assertRaisesRegexp(ValueError,342                                 "Invalid second item in interval:"):343      command_parser.parse_time_interval("[ 0ms, _ms]")344    with self.assertRaisesRegexp(ValueError, "Invalid first item in interval:"):345      command_parser.parse_time_interval("(xms, _ms]")346    with self.assertRaisesRegexp(ValueError, "Invalid first item in interval:"):347      command_parser.parse_time_interval("((3ms, _ms)")348  def testInvalidTimeIntervalRaisesException(self):349    with self.assertRaisesRegexp(350        ValueError,351        r"Invalid interval format: \[10us, 1ms. Valid formats are: "352        r"\[min, max\], \(min, max\), <max, >min"):353      command_parser.parse_time_interval("[10us, 1ms")354    with self.assertRaisesRegexp(355        ValueError,356        r"Incorrect interval format: \[10us, 1ms, 2ms\]. Interval should "357        r"specify two values: \[min, max\] or \(min, max\)"):358      command_parser.parse_time_interval("[10us, 1ms, 2ms]")359    with self.assertRaisesRegexp(360        ValueError,361        r"Invalid interval \[1s, 1ms\]. Start must be before end of interval."):362      command_parser.parse_time_interval("[1s, 1ms]")363  def testParseMemoryInterval(self):364    self.assertEquals(365        command_parser.Interval(1024, True, 2048, True),366        command_parser.parse_memory_interval("[1k, 2k]"))367    self.assertEquals(368        command_parser.Interval(1024, False, 2048, False),369        command_parser.parse_memory_interval("(1kB, 2kB)"))370    self.assertEquals(371        command_parser.Interval(1024, False, 2048, True),372        command_parser.parse_memory_interval("(1k, 2k]"))373    self.assertEquals(374        command_parser.Interval(1024, True, 2048, False),375        command_parser.parse_memory_interval("[1k, 2k)"))376    self.assertEquals(377        command_parser.Interval(0, False, 2048, True),378        command_parser.parse_memory_interval("<=2k"))379    self.assertEquals(380        command_parser.Interval(11, True, float("inf"), False),381        command_parser.parse_memory_interval(">=11"))382    self.assertEquals(command_parser.Interval(0, False, 2048, False),383                      command_parser.parse_memory_interval("<2k"))384    self.assertEquals(385        command_parser.Interval(11, False, float("inf"), False),386        command_parser.parse_memory_interval(">11"))387  def testParseMemoryIntervalsWithInvalidValueStrings(self):388    with self.assertRaisesRegexp(ValueError, "Invalid value string after >= "):389      command_parser.parse_time_interval(">=wM")390    with self.assertRaisesRegexp(ValueError, "Invalid value string after > "):391      command_parser.parse_time_interval(">YM")392    with self.assertRaisesRegexp(ValueError, "Invalid value string after <= "):393      command_parser.parse_time_interval("<= _MB")394    with self.assertRaisesRegexp(ValueError, "Invalid value string after < "):395      command_parser.parse_time_interval("<-MB")396  def testInvalidMemoryIntervalRaisesException(self):397    with self.assertRaisesRegexp(398        ValueError,399        r"Invalid interval \[5k, 3k\]. Start of interval must be less than or "400        "equal to end of interval."):401      command_parser.parse_memory_interval("[5k, 3k]")402  def testIntervalContains(self):403    interval = command_parser.Interval(404        start=1, start_included=True, end=10, end_included=True)405    self.assertTrue(interval.contains(1))406    self.assertTrue(interval.contains(10))407    self.assertTrue(interval.contains(5))408    interval.start_included = False409    self.assertFalse(interval.contains(1))410    self.assertTrue(interval.contains(10))411    interval.end_included = False412    self.assertFalse(interval.contains(1))413    self.assertFalse(interval.contains(10))414    interval.start_included = True415    self.assertTrue(interval.contains(1))416    self.assertFalse(interval.contains(10))417if __name__ == "__main__":...

Full Screen

Full Screen

smellentitiez.py

Source:smellentitiez.py Github

copy

Full Screen

...65            cnt += 166class BasicSmellz(Smellz):67    def __init__(self, smellName):68        Smellz.__init__(self, smellName)69    def parse(self, toParse):70        """71        input is a splitted assertionless dump line, eg72        ["AssertionLess", "FooTest.testFoo()", "FooTest.java", "25"]73        pre:74            toParse[0] == self.smellName75            len(toParse) == 476            isSourceLine(toParse[3])77        post:78            self.hasKey(toParse[1])79            self.getLocation(toParse[1]) == (toParse[2], int(toParse[3]))80        """81        self.dict[toParse[1]] = [(toParse[2], int(toParse[3]))]82class AssertionLesss(BasicSmellz):83    def __init__(self):84        BasicSmellz.__init__(self, "AssertionLess")85class EmptyTests(BasicSmellz):86    def __init__(self):87        BasicSmellz.__init__(self, "EmptyTest")88class ForTestersOnlys(BasicSmellz):89    def __init__(self):90        BasicSmellz.__init__(self, "ForTestersOnly")91    def generateEdges(self):92        # disable the edges, temporarily since guess crashes on non-existant nodes93        return []94class AssertionRoulettes(Smellz):95    def __init__(self):96        Smellz.__init__(self, "AssertionRoulette")97        self.nodeColor = "red"98        self.entityType = "smell"99        self.style = SMELL_STYLE100    def parse(self, toParse):101        """102        input is a splitted assertionroulette dump line, eg103        [ "AssertionRoulette", "TC", "FooTest.testFoo()", "10", "8", "FooTest.java", "228"]104        pre:105            toParse[0] == "AssertionRoulette"106            len(toParse) == 7107            isSourceLine(toParse[6])108            isCount(toParse[3])109            isCount(toParse[4])110            int(toParse[3]) >= int(toParse[4])111        post:112            self.hasKey(toParse[2])113            self.getLocation(toParse[2]) == (toParse[5], int(toParse[6]))114            isCount(self.getTotalAsserts(toParse[2]))115            isCount(self.getDescriptionlessAsserts(toParse[2]))116        """117        self.dict[toParse[2]] = [(toParse[5], int(toParse[6])), int(toParse[3]), int(toParse[4])]118    119    def getTotalAsserts(self, key):120        """121        key is a qualified testmethod name with asertionroulette smell122        pre:123            self.hasKey(key)124        """125        return self.dict[key][1]126    127    def getDescriptionlessAsserts(self, key):128        """129        key is a qualified testmethod name with asertionroulette smell130        pre:131            self.hasKey(key)132        """133        return self.dict[key][2]134    #def appendMetricInfo(self, metricDict):135        #cnt = 0136        #metricDict["AssertionRoulette"] = {}137        #arMtr = metricDict["AssertionRoulette"]138        #for entity in self.dict:139            #key = 'AssertionRoulette' + str(cnt)140            #arMtr[key] = {'NrA' : self.getTotalAsserts(entity), \141                          #'NrDA' : self.getDescriptionlessAsserts(entity)}142            #cnt += 1143    def appendMetricInfo(self, metricDict):144        metricDict['Translation']['NrA'] = "Number of assert invocations"145        metricDict['Translation']['NrDA'] = "Number of Descriptionless assert invocations"146        self.appendMetricInfoHelper(metricDict, [('NrA', self.getTotalAsserts), \147                                                 ('NrDA', self.getDescriptionlessAsserts)]) # Number of Control Structures148class TypedSmell(Smellz):149    def __init__(self, smellName):150        Smellz.__init__(self, smellName)151        self.smellName = smellName152        self.nodeColor = "red"153        self.entityType = "smell"154        self.style = SMELL_STYLE155    156    def parse(self, toParse):157        """158        input is a splitted indentedtest dump line, eg159        ["IndentedTest","TC","FileTest.testRemove()","1","FileTest.cc","78"]160        pre:161            toParse[0] == self.smellName162            len(toParse) == 6163            isSourceLine(toParse[5])164            isCount(toParse[3])165            toParse[1] in ["TC", "TH"]166        post:167            self.hasKey(toParse[2])168            self.getLocation(toParse[2]) == (toParse[4], int(toParse[5]))169            self.getType(toParse[2]) == toParse[1]170            self.getCount(toParse[2]) == int(toParse[3])171        """172        self.dict[toParse[2]] = [(toParse[4], int(toParse[5])), int(toParse[3]), toParse[1]]173    def getType(self, testMethod):174        """175        pre:176            self.hasKey(testMethod)177        """178        return self.dict[testMethod][2]179    180    def getCount(self, testMethod):181        """182        pre:183            self.hasKey(testMethod)184        """185        return self.dict[testMethod][1]186class IndentedTests(TypedSmell):187    def __init__(self):188        TypedSmell.__init__(self, "IndentedTest")189    def appendMetricInfo(self, metricDict):190        metricDict['Translation']['NrCS'] = "Number of control structures"191        self.appendMetricInfoHelper(metricDict, [('NrCS', self.getCount)]) # Number of Control Structures192class SensitiveEqualitys(TypedSmell):193    def __init__(self):194        TypedSmell.__init__(self, "SensitiveEquality")195    def appendMetricInfo(self, metricDict):196        metricDict['Translation']['NrTS'] = "Number of toString invocations"197        self.appendMetricInfoHelper(metricDict, [('NrTS', self.getCount)]) # Number of toStrings198class VerboseTests(Smellz):199    def __init__(self):200        Smellz.__init__(self, "VerboseTest")201    def parse(self, toParse):202        """203        input is a splitted indirectests dump line, eg204        ["VerboseTest","FooTest.testFoo()","20","FooTest.java","57"]205        pre:206            toParse[0] == "VerboseTest"207            len(toParse) == 5208            isSourceLine(toParse[4])209            isCount(toParse[2])210        post:211            self.hasKey(toParse[1])212            self.getLocation(toParse[1]) == (toParse[3], int(toParse[4]))213            self.getMetric(toParse[1]) == int(toParse[2])214        """215        self.dict[toParse[1]] = [(toParse[3], int(toParse[4])), int(toParse[2])]216    def getMetric(self, testMethod):217        """218        pre:219            self.hasKey(testMethod)220        """221        return self.dict[testMethod][1]222    def appendMetricInfo(self, metricDict):223        metricDict['Translation']['LOC'] = "Lines of code"224        self.appendMetricInfoHelper(metricDict, [('LOC', self.getMetric)])225class SingleMetricSmellz(Smellz):226    def __init__(self, smellName):227        Smellz.__init__(self, smellName)228        229    def parse(self, toParse):230        """231        input is a splitted indirectests dump line, eg232        ["IndirectTest","BtDependencyTest.testResolve()","4","5","BtDependencyTest.cc","57"]233        pre:234            toParse[0] == self.smellName235            len(toParse) == 6236            isSourceLine(toParse[5])237            isCount(toParse[2])238            isCount(toParse[3])239        post:240            self.hasKey(toParse[1])241            self.getLocation(toParse[1]) == (toParse[4], int(toParse[5]))242            self.getTreshold(toParse[1]) == int(toParse[2])243            self.getMetric(toParse[1]) == int(toParse[3])244        """245        self.dict[toParse[1]] = [(toParse[4], int(toParse[5])), int(toParse[2]), int(toParse[3])]246    def getTreshold(self, testMethod):247        """248        pre:249            self.hasKey(testMethod)250        """251        return self.dict[testMethod][1]252    253    def getMetric(self, testMethod):254        """255        pre:256            self.hasKey(testMethod)257        """258        return self.dict[testMethod][2]259class IndirectTests(SingleMetricSmellz):260    def __init__(self):261        SingleMetricSmellz.__init__(self, "IndirectTest")262    def getNPTU(self, testMethod):263        return self.getMetric(testMethod)264    def appendMetricInfo(self, metricDict):265        metricDict['Translation']['NPTU'] = "Number of production type uses"266        self.appendMetricInfoHelper(metricDict, [('NPTU', self.getNPTU)]) # Number of Production Type Uses267class EagerTests(SingleMetricSmellz):268    def __init__(self):269        SingleMetricSmellz.__init__(self, "EagerTest")270    def getPTMI(self, testMethod):271        return self.getMetric(testMethod)272    def appendMetricInfo(self, metricDict):273        metricDict['Translation']['PTMI'] = "Number of production method invocations"274        self.appendMetricInfoHelper(metricDict, [('PTMI', self.getPTMI)]) # Number of Production Type Method Invocations275class MysteryGuests(object):276    def __init__(self):277        self.mysteries = []278    def generateEdges(self):279        edges = []280        counter = 0281        for mystery in self.mysteries:282            edges.append(Edge(mystery[1], "MysteryGuest" + str(counter)))283            counter += 1284        return edges285    def generateNodes(self):286        nodes = []287        counter = 0288        for mystery in self.mysteries:289            nodes.append(Node(name="MysteryGuest" + str(counter),\290                         color="black", label="MysteryGuest", \291                         entity="smell", style=SMELL_STYLE ))292            counter += 1293        return nodes294    def appendLocationInfo(self, srcDict):295        counter = 0296        for mystery in self.mysteries:297            srcDict["MysteryGuest" + str(counter)] = [(mystery[2], int(mystery[3])), (mystery[5], int(mystery[6]))]298            counter += 1299    def __isDirectMystery(self, mystery):300        # a mystery guest is direct if the blacklisted method gets called301        # in the testcommand/helper/setup.302        return (mystery[2] == mystery[5]) and (mystery[3] == mystery[6])303    def parse(self, toParse):304        """305        input is a splitted mysteryguest dump line eg306        ["MysteryGuest",307         "MysteryTest.testSomething()", "MysteryTest.java", "5",\308         "MyOtherProductionClass.myOtherMethod(String)","MyOtherProductionClass.java","6",\309         "file","java::io::BufferedReader.readLine()"]310        311        pre:312            toParse[0] == "MysteryGuest"313            isSourceLine(toParse[3])314            isSourceLine(toParse[6])315        """316        self.mysteries.append(toParse)317    def appendMetricInfo(self, metricDict):318        pass319class GeneralFixtures(Smellz):320    def __init__(self):321        Smellz.__init__(self, "GeneralFixture")322    def parse(self, toParse):323        """ ["GeneralFixture","DefaultPackageTest",324                        "5","6","10","DefaultPackageTest.java","0"]"""325        self.dict[toParse[1]] = [(toParse[-2], int(toParse[-1])), int(toParse[2]), int(toParse[3]), int(toParse[4])]326    def getNFOB(self, testcase):327        return self.dict[testcase][1]328    def getNFPT(self, testcase):329        return self.dict[testcase][2]330    def getNOBU(self, testcase):331        return self.dict[testcase][3]332    def appendMetricInfo(self, metricDict):333        metricDict['Translation']['NFOB'] = "Number of fixture objects"334        metricDict['Translation']['NFPT'] = "Number of fixture production types"335        metricDict['Translation']['NOBU'] = "Number of object uses"336        self.appendMetricInfoHelper(metricDict, [('NFOB', self.getNFOB),\337                                                 ('NFPT', self.getNFPT),\338                                                 ('NOBU', self.getNOBU)])339class DuplicatedCodes(object):340    def __init__(self):341        self.duplicates = []342        self.smellName = "DuplicatedCode"343    def generateEdges(self):344        edges = []345        counter = 0346        for duplicate in self.duplicates:347            processedMtds = set()348            for i in range(1, len(duplicate), 4):349                currMtd = filterComma(duplicate[i])350                if currMtd in processedMtds: continue351                edges.append(Edge(currMtd, self.smellName + str(counter)))352                processedMtds.add(currMtd)353            counter += 1354        return edges355    def generateNodes(self):356        nodes = []357        counter = 0358        for duplicate in self.duplicates:359            nodes.append(Node(name=self.smellName + str(counter),\360                         color="red", label=self.smellName, \361                         entity="smell", style=SMELL_STYLE ))362            counter += 1363        return nodes364    def appendLocationInfo(self, srcDict):365        counter = 0366        for duplicate in self.duplicates:367            srcDict[self.smellName + str(counter)] = []368            entry = srcDict[self.smellName + str(counter)]369            for i in range(2, len(duplicate), 4):370                entry.append((duplicate[i], int(duplicate[i+1]), int(duplicate[i+2])))371            counter += 1372    def parse(self, toParse):373        """374        input is a splitted duplicatedcode dump line, eg375        ["DuplicatedCode", \376            "FooTest.testFoo()", "FooTest.java", "197", "206", 377            "BazTest.testBaz()", "BazTest.java", "183", "193"]378        pre:379            toParse[0] == "DuplicatedCode"380            len(toParse) % 4  == 1381            forall(isSourceLine(i) for i in range(3,len(toParse),3))382            forall(isSourceLine(i) for i in range(4,len(toParse),3))383        """384        self.duplicates.append(toParse)385    def calculateANrSL(self, duplicate):386        ''' Average Number of Sourcelines '''...

Full Screen

Full Screen

autopart.py

Source:autopart.py Github

copy

Full Screen

...39class FC3_TestCase(CommandTest):40    command = "autopart"41    def runTest(self):42        # pass43        self.assert_parse("autopart", "autopart\n")44        # fail - on FC3, autopart  took no options so this raises a different45        # exception than later releases.46        if self.__class__.__name__ == "FC3_TestCase":47            self.assert_parse_error("autopart --blah")48class F9_TestCase(FC3_TestCase):49    def runTest(self):50        FC3_TestCase.runTest(self)51        # pass52        self.assert_parse("autopart --passphrase=whatever", "autopart\n")53        self.assert_parse("autopart --encrypted", "autopart --encrypted\n")54        self.assert_parse("autopart --encrypted --passphrase=\"whatever\"",55                          "autopart --encrypted --passphrase=\"whatever\"\n")56        self.assert_parse("autopart --encrypted --passphrase=whatever",57                          "autopart --encrypted --passphrase=\"whatever\"\n")58        # fail59        self.assert_parse_error("autopart --passphrase")60        self.assert_parse_error("autopart --encrypted --passphrase")61        self.assert_parse_error("autopart --encrypted=False")62        self.assert_parse_error("autopart --encrypted=True")63class F12_TestCase(F9_TestCase):64    def runTest(self):65        # Run F9 test case66        F9_TestCase.runTest(self)67        # pass68        self.assert_parse("autopart --escrowcert=\"http://x/y\"", "autopart\n")69        self.assert_parse("autopart --encrypted --backuppassphrase",70                          "autopart --encrypted\n")71        self.assert_parse("autopart --encrypted --escrowcert=\"http://x/y\"",72                          "autopart --encrypted --escrowcert=\"http://x/y\"\n")73        self.assert_parse("autopart --encrypted --escrowcert=\"http://x/y\" "74                          "--backuppassphrase",75                          "autopart --encrypted --escrowcert=\"http://x/y\" "76                          "--backuppassphrase\n")77        self.assert_parse("autopart --encrypted --escrowcert=http://x/y",78                          "autopart --encrypted --escrowcert=\"http://x/y\"\n")79        # fail80        self.assert_parse_error("autopart --escrowcert")81        self.assert_parse_error("autopart --escrowcert --backuppassphrase")82        self.assert_parse_error("autopart --encrypted --escrowcert "83                                "--backuppassphrase")84        self.assert_parse_error("autopart --backuppassphrase=False")85        self.assert_parse_error("autopart --backuppassphrase=True")86class RHEL6_TestCase(F12_TestCase):87    def runTest(self):88        F12_TestCase.runTest(self)89        # pass90        self.assert_parse("autopart --cipher=foo", "autopart\n")91        self.assert_parse("autopart --encrypted --cipher=3-rot13",92                          "autopart --encrypted --cipher=\"3-rot13\"\n")93        # fail94        self.assert_parse_error("autopart --cipher")95        self.assert_parse_error("autopart --encrypted --cipher")96        # extra test coverage97        cmd = RHEL6_AutoPart()98        self.assertEqual(cmd.__str__(), '')99class RHEL6_Conflict_TestCase(CommandSequenceTest):100    def __init__(self, *args, **kwargs):101        CommandSequenceTest.__init__(self, *args, **kwargs)102        self.version = RHEL6103    def runTest(self):104        self.assert_parse_error("""105part / --size=1024 --fstype=ext4106autopart""")107        self.assert_parse_error("""108raid / --device=md0 --level=0 raid.01109autopart""")110        self.assert_parse_error("""111volgroup vg.01 pv.01 --pesize=70000112autopart""")113        self.assert_parse_error("""114logvol / --size=10240 --name=NAME --vgname=VGNAM115autopart""")116class F16_TestCase(F12_TestCase):117    def runTest(self):118        # Run F12 test case119        F12_TestCase.runTest(self)120        if "--type" not in self.optionList:121            # pass122            self.assert_parse("autopart --nolvm",123                              "autopart --nolvm\n")124            # fail125            self.assert_parse_error("autopart --nolvm=asdf")126            self.assert_parse_error("autopart --nolvm True")127            self.assert_parse_error("autopart --nolvm=1")128            self.assert_parse_error("autopart --nolvm 0")129class F17_TestCase(F16_TestCase):130    def runTest(self):131        # Run F16 test case132        F16_TestCase.runTest(self)133        # pass134        self.assert_parse("autopart --type=plain",135                          "autopart --type=plain\n")136        self.assert_parse("autopart --type=partition",137                          "autopart --type=plain\n")138        self.assert_parse("autopart --type=lvm",139                          "autopart --type=lvm\n")140        if self.__class__.__name__ != "RHEL8_TestCase":141            self.assert_parse("autopart --type=btrfs",142                              "autopart --type=btrfs\n")143        self.assert_parse("autopart --nolvm",144                          "autopart --type=plain\n")145        # don't add --type= if none was specified146        self.assert_parse("autopart",147                          "autopart\n")148        # fail149        self.assert_parse_error("autopart --type")150        self.assert_parse_error("autopart --type=blah")151class F18_TestCase(F17_TestCase):152    def runTest(self):153        F17_TestCase.runTest(self)154        # pass155        self.assert_parse("autopart --cipher=foo", "autopart\n")156        self.assert_parse("autopart --encrypted --cipher=3-rot13",157                          "autopart --encrypted --cipher=\"3-rot13\"\n")158        # fail159        self.assert_parse_error("autopart --cipher")160        self.assert_parse_error("autopart --encrypted --cipher")161class F20_TestCase(F18_TestCase):162    def runTest(self):163        F18_TestCase.runTest(self)164        self.assert_parse("autopart --type=thinp",165                          "autopart --type=thinp\n")166class F21_TestCase(F20_TestCase):167    def runTest(self):168        F20_TestCase.runTest(self)169        # pass170        self.assert_parse("autopart --fstype=ext4",171                          'autopart --fstype=ext4\n')172        self.assert_parse("autopart --encrypted --fstype=ext4",173                          'autopart --encrypted --fstype=ext4\n')174        self.assert_parse("autopart --type=lvm --fstype=xfs",175                          "autopart --type=lvm --fstype=xfs\n")176        # fail177        self.assert_parse_error("autopart --fstype")178        self.assert_parse_error("autopart --fstype=btrfs")179        self.assert_parse_error("autopart --type=btrfs --fstype=xfs")180class F21_Conflict_TestCase(CommandSequenceTest):181    def __init__(self, *args, **kwargs):182        CommandSequenceTest.__init__(self, *args, **kwargs)183        self.version = F21184    def runTest(self):185        self.assert_parse_error("""186part / --size=1024 --fstype=ext4187autopart""")188        self.assert_parse_error("""189raid / --device=md0 --level=0 raid.01190autopart""")191        self.assert_parse_error("""192volgroup vg.01 pv.01 --pesize=70000193autopart""")194        self.assert_parse_error("""195logvol / --size=10240 --name=NAME --vgname=VGNAM196autopart""")197class F23_TestCase(F21_TestCase):198    def runTest(self):199        F21_TestCase.runTest(self)200class F23_Conflict_TestCase(F21_Conflict_TestCase):201    """202        reqpart was added in Fedora 23 but the autopart handler203        wasn't updated. Instead the changes were introduced into204        F20_AutoPart, which wasn't the best thing to do.205    """206    def __init__(self, *args, **kwargs):207        F21_Conflict_TestCase.__init__(self, *args, **kwargs)208        self.version = F23209    def runTest(self):210        F21_Conflict_TestCase.runTest(self)211        self.assert_parse_error("""212reqpart213autopart""")214class RHEL7_TestCase(F21_TestCase):215    def runTest(self):216        F21_TestCase.runTest(self)217        # pass218        self.assert_parse("autopart --nohome",219                          "autopart --nohome\n")220        # fail221        self.assert_parse_error("autopart --nohome=xxx")222        self.assert_parse_error("autopart --nohome True")223        self.assert_parse_error("autopart --nohome=1")224        self.assert_parse_error("autopart --nohome 0")225class RHEL7_Conflict_TestCase(CommandSequenceTest):226    def __init__(self, *args, **kwargs):227        CommandSequenceTest.__init__(self, *args, **kwargs)228        self.version = RHEL7229    def runTest(self):230        self.assert_parse_error("""231reqpart232autopart""")233class F26_TestCase(F23_TestCase):234    def runTest(self):235        F23_TestCase.runTest(self)236        # pass237        self.assert_parse("autopart --nohome",238                          'autopart --nohome\n')239        self.assert_parse("autopart --noboot",240                          'autopart --noboot\n')241        self.assert_parse("autopart --noswap",242                          'autopart --noswap\n')243        self.assert_parse("autopart --nohome --noboot --noswap",244                          'autopart --nohome --noboot --noswap\n')245        # fail246        self.assert_parse_error("autopart --nohome=xxx")247        self.assert_parse_error("autopart --nohome True")248        self.assert_parse_error("autopart --nohome=1")249        self.assert_parse_error("autopart --nohome 0")250        self.assert_parse_error("autopart --noboot=xxx")251        self.assert_parse_error("autopart --noboot True")252        self.assert_parse_error("autopart --noboot=1")253        self.assert_parse_error("autopart --noboot 0")254        self.assert_parse_error("autopart --noswap=xxx")255        self.assert_parse_error("autopart --noswap True")256        self.assert_parse_error("autopart --noswap=1")257        self.assert_parse_error("autopart --noswap 0")258class F26_Conflict_TestCase(F23_Conflict_TestCase):259    def runTest(self):260        F23_Conflict_TestCase.runTest(self)261class F29_TestCase(F26_TestCase):262    def runTest(self):263        F26_TestCase.runTest(self)264        self.assert_parse("autopart --encrypted --luks-version=luks2",265                          "autopart --encrypted --luks-version=luks2\n")266        self.assert_parse("autopart --encrypted --pbkdf=argon2i",267                          "autopart --encrypted --pbkdf=argon2i\n")268        self.assert_parse("autopart --encrypted --pbkdf-memory=256",269                          "autopart --encrypted --pbkdf-memory=256\n")270        self.assert_parse("autopart --encrypted --pbkdf-time=100",271                          "autopart --encrypted --pbkdf-time=100\n")272        self.assert_parse("autopart --encrypted --pbkdf-iterations=1000",273                          "autopart --encrypted --pbkdf-iterations=1000\n")274        self.assert_parse_error("autopart --encrypted --pbkdf-time=100 --pbkdf-iterations=1000")275class RHEL8_TestCase(F29_TestCase):276    def runTest(self):277        F29_TestCase.runTest(self)278        self.assert_parse_error("autopart --type=btrfs")279if __name__ == "__main__":...

Full Screen

Full Screen

test_parser_pddl_simple.py

Source:test_parser_pddl_simple.py Github

copy

Full Screen

1#!/usr/bin/python32from pddl.parser import *3from pddl.lisp_parser import parse_lisp_iterator4from pddl.errors import BraceError, ParseError5from py.test import raises6## helper functions7def varListTest(varList):8    assert  [k.name for k in varList] == ['?x', '?y', '?z']9    assert  len([k for k in varList if k.typed]) == 310    assert  [k.types[0] for k in varList] == ['block', 'foo', 'block']11def keywordListTest(keyList):12    assert  [k.name for k in keyList] == ['name', 'parameters', 'foo']13## the tests14def test_parseKeywordSimple():15    test = ['(:parameters )']16    iter = parse_lisp_iterator(test)17    key = parse_keyword(next(iter))18    assert key.name == 'parameters'19def test_parseKeywordComplex():20    test = [' ( :name)']21    iter = parse_lisp_iterator(test)22    key = parse_keyword(next(iter))23    assert key.name == 'name'24def test_parseKeywordList():25    test = ['(:name :parameters :foo )']26    iter = parse_lisp_iterator(test)27    keys = parse_keyword_list(iter)28    assert iter.empty()29    keywordListTest(keys)30def test_parseRequirements():31    test = ['(:requirements :name :parameters :foo )']32    iter = parse_lisp_iterator(test)33    req = parse_requirements_stmt(iter)34    assert iter.empty()35    keywordListTest(req.keywords)36def test_parseRequirements2():37    test = ['(:predicates :name :parameters :foo )']38    iter = parse_lisp_iterator(test)39    with raises(ValueError):40        parse_requirements_stmt(iter)41def test_parseVariableNoTyping():42    test = [' ( ?x)']43    iter = parse_lisp_iterator(test)44    key = parse_variable(next(iter))45    assert key.name == '?x'46    assert key.typed == False47    assert key.types == None48def test_parseVariableTyping():49    test = [' ( ?x - block)']50    iter = parse_lisp_iterator(test)51    vlist = parse_typed_var_list(iter)52    assert len(vlist) == 153    assert vlist[0].name == '?x'54    assert vlist[0].typed == True55    assert vlist[0].types[0] == 'block'56def test_parseVariableList():57    test = [' ( ?x - block ?y - foo ?z - block  )']58    iter = parse_lisp_iterator(test)59    key = parse_typed_var_list(iter)60    varListTest(key)61def test_parseParameters():62    test = ['(:parameters ( ?x - block ?y - foo ?z - block  ))']63    iter = parse_lisp_iterator(test)64    key = parse_parameters(iter)65    varListTest(key)66def test_parseParameters2():67    test = ['(:predicates ( ?x - block ?y - foo ?z - block  ))']68    iter = parse_lisp_iterator(test)69    with raises(ValueError):70        parse_parameters(iter)71def test_parseTypes():72    test = ['(:types block plane key)']73    iter = parse_lisp_iterator(test)74    tlist = parse_types_stmt(iter)75    assert [t.name for t in tlist] == ['block', 'plane', 'key']76def test_parseTypesFail():77    test = ['(:types :block plane key)']78    iter = parse_lisp_iterator(test)79    with raises(ValueError):80        parse_types_stmt(iter)81def test_parseTypesFail2():82    test = ['(:predicates :block plane key)']83    iter = parse_lisp_iterator(test)84    with raises(ValueError):85        parse_types_stmt(iter)86def test_parseDomainStatement():87    test = ['(domain supertest-23-v0)']88    iter = parse_lisp_iterator(test)89    dom = parse_domain_stmt(iter)90    assert dom.name == 'supertest-23-v0'91def test_parseDomainStatementFail():92    test = ['(domaiin supertest-23-v0)']93    iter = parse_lisp_iterator(test)94    with raises(ValueError):95        parse_domain_stmt(iter)96def test_parsePredicate():97    test = ['(on ?x ?y)']98    iter = parse_lisp_iterator(test)99    pred = parse_predicate(iter)100    assert pred.name == 'on'101    assert [x.name for x in pred.parameters] == ['?x', '?y']102def test_parsePredicateMixed():103    test = ['(on ?x - block ?y)']104    iter = parse_lisp_iterator(test)105    pred = parse_predicate(iter)106    assert pred.name == 'on'107    assert [x.name for x in pred.parameters] == ['?x', '?y']108    assert [x.types[0] for x in pred.parameters109            if x.types != None] == ['block']110def test_parsePredicateList():111    test = ['((on ?x - block ?y) (put ?x ?z) (true))']112    iter = parse_lisp_iterator(test)113    predlist = parse_predicate_list(iter)114    assert [x.name for x in predlist] == ['on', 'put', 'true']115def test_parseFormula():116    test = ['(and (on ?x table) (true) (free ?x))']117    iter = parse_lisp_iterator(test)118    print(iter)119    formula = parse_formula(iter)120    assert formula.key == 'and'121    assert [c.key for c in formula.children] == ['on', 'true', 'free']122    assert [c.key.name for c in formula.children[0].children123            if c.type == TypeVariable] == ['?x']124    assert [c.key for c in formula.children[0].children125            if c.type == TypeConstant] == ['table']126    assert [c.key.name for c in formula.children[2].children127            if c.type == TypeVariable] == ['?x']128    assert [c for c in formula.children[1].children] == []129def test_parseFormulaFail():130    test = ['(and (on ?x table) (:true) (free ?x))']131    iter = parse_lisp_iterator(test)132    with raises(ValueError):133        parse_formula(iter)134def test_parseFormulaLispFail2():135    test = ['(and (on ?x table) (true) (free( ?x))']136    with raises(ParseError):137        iter = parse_lisp_iterator(test)138def test_parse_variable():139    test = ['(x)']140    iter = parse_lisp_iterator(test)141    with raises(ValueError):142        parse_variable(next(iter))143def test_lisp_parser_start_brace():144    test = ['test string)']145    with raises(ParseError):146        iter = parse_lisp_iterator(test)147def test_parse_keyword_raise():148    test = ['(?test)']149    iter = parse_lisp_iterator(test)150    with raises(ValueError):151        parse_keyword(next(iter))152def test_parse_objects_stmt_fail():153    test = ['(:predicates blubb blubb)']154    iter = parse_lisp_iterator(test)155    with raises(ValueError):156        parse_objects_stmt(iter)157def test_parse_constants_stmt_fail():158    test = ['(:predicates blubb blubb)']159    iter = parse_lisp_iterator(test)160    with raises(ValueError):161        parse_constants_stmt(iter)162def test_parse_problem_domain_stmt_fail():163    test = ['(:predicates blubb blubb)']164    iter = parse_lisp_iterator(test)165    with raises(ValueError):166        parse_problem_domain_stmt(iter)167def test_parse_precondition_stmt_fail():168    test = ['(:predicates blubb blubb)']169    iter = parse_lisp_iterator(test)170    with raises(ValueError):171        parse_precondition_stmt(iter)172def test_parse_effect_stmt_fail():173    test = ['(:predicates blubb blubb)']174    iter = parse_lisp_iterator(test)175    with raises(ValueError):176        parse_effect_stmt(iter)177def test_parse_action_stmt_fail():178    test = ['(:predicates blubb blubb)']179    iter = parse_lisp_iterator(test)180    with raises(ValueError):181        parse_action_stmt(iter)182def test_parse_predicates_stmt_fail():183    test = ['(:actions blubb blubb)']184    iter = parse_lisp_iterator(test)185    with raises(ValueError):186        parse_predicates_stmt(iter)187def test_parse_domain_def_fail():188    test = ['(definiere (domain BLOCKS))']189    iter = parse_lisp_iterator(test)190    with raises(ValueError):191        parse_domain_def(iter)192def test_parse_problem_def_fail():193    test = ['(definiere problem)']194    iter = parse_lisp_iterator(test)195    with raises(ValueError):196        parse_problem_def(iter)197def test_parse_problem_name_fail():198    test = ['(domain test)']199    iter = parse_lisp_iterator(test)200    with raises(ValueError):201        parse_problem_name(iter)202def test_parse_init_stmt_fail():203    test = ['(:goal ssdfsdf)']204    iter = parse_lisp_iterator(test)205    with raises(ValueError):206        parse_init_stmt(iter)207def test_parse_goal_stmt_fail():208    test = ['(:init ssdfsdf)']209    iter = parse_lisp_iterator(test)210    with raises(ValueError):...

Full Screen

Full Screen

test_expressionparser.py

Source:test_expressionparser.py Github

copy

Full Screen

...5from manifestparser import parse6class ExpressionParserTest(unittest.TestCase):7    """Test the conditional expression parser."""8    def test_basic(self):9        self.assertEqual(parse("1"), 1)10        self.assertEqual(parse("100"), 100)11        self.assertEqual(parse("true"), True)12        self.assertEqual(parse("false"), False)13        self.assertEqual('', parse('""'))14        self.assertEqual(parse('"foo bar"'), 'foo bar')15        self.assertEqual(parse("'foo bar'"), 'foo bar')16        self.assertEqual(parse("foo", foo=1), 1)17        self.assertEqual(parse("bar", bar=True), True)18        self.assertEqual(parse("abc123", abc123="xyz"), 'xyz')19    def test_equality(self):20        self.assertTrue(parse("true == true"))21        self.assertTrue(parse("false == false"))22        self.assertTrue(parse("1 == 1"))23        self.assertTrue(parse("100 == 100"))24        self.assertTrue(parse('"some text" == "some text"'))25        self.assertTrue(parse("true != false"))26        self.assertTrue(parse("1 != 2"))27        self.assertTrue(parse('"text" != "other text"'))28        self.assertTrue(parse("foo == true", foo=True))29        self.assertTrue(parse("foo == 1", foo=1))30        self.assertTrue(parse('foo == "bar"', foo='bar'))31        self.assertTrue(parse("foo == bar", foo=True, bar=True))32        self.assertTrue(parse("true == foo", foo=True))33        self.assertTrue(parse("foo != true", foo=False))34        self.assertTrue(parse("foo != 2", foo=1))35        self.assertTrue(parse('foo != "bar"', foo='abc'))36        self.assertTrue(parse("foo != bar", foo=True, bar=False))37        self.assertTrue(parse("true != foo", foo=False))38        self.assertTrue(parse("!false"))39    def test_conjunctures(self):40        self.assertTrue(parse("true && true"))41        self.assertTrue(parse("true || false"))42        self.assertFalse(parse("false || false"))43        self.assertFalse(parse("true && false"))44        self.assertTrue(parse("true || false && false"))45    def test_parentheses(self):46        self.assertTrue(parse("(true)"))47        self.assertEqual(parse("(10)"), 10)48        self.assertEqual(parse('("foo")'), 'foo')49        self.assertEqual(parse("(foo)", foo=1), 1)50        self.assertTrue(parse("(true == true)"), True)51        self.assertTrue(parse("(true != false)"))52        self.assertTrue(parse("(true && true)"))53        self.assertTrue(parse("(true || false)"))54        self.assertTrue(parse("(true && true || false)"))55        self.assertFalse(parse("(true || false) && false"))56        self.assertTrue(parse("(true || false) && true"))57        self.assertTrue(parse("true && (true || false)"))58        self.assertTrue(parse("true && (true || false)"))59        self.assertTrue(parse("(true && false) || (true && (true || false))"))60    def test_comments(self):61        # comments in expressions work accidentally, via an implementation62        # detail - the '#' character doesn't match any of the regular63        # expressions we specify as tokens, and thus are ignored.64        # However, having explicit tests for them means that should the65        # implementation ever change, comments continue to work, even if that66        # means a new implementation must handle them explicitly.67        self.assertTrue(parse("true == true # it does!"))68        self.assertTrue(parse("false == false # it does"))69        self.assertTrue(parse("false != true # it doesnt"))70        self.assertTrue(parse('"string with #" == "string with #" # really, it does'))71        self.assertTrue(parse('"string with #" != "string with # but not the same" # no match!'))72    def test_not(self):73        """74        Test the ! operator.75        """76        self.assertTrue(parse("!false"))77        self.assertTrue(parse("!(false)"))78        self.assertFalse(parse("!true"))79        self.assertFalse(parse("!(true)"))80        self.assertTrue(parse("!true || true)"))81        self.assertTrue(parse("true || !true)"))82        self.assertFalse(parse("!true && true"))83        self.assertFalse(parse("true && !true"))84    def test_lesser_than(self):85        """86        Test the < operator.87        """88        self.assertTrue(parse("1 < 2"))89        self.assertFalse(parse("3 < 2"))90        self.assertTrue(parse("false || (1 < 2)"))91        self.assertTrue(parse("1 < 2 && true"))92        self.assertTrue(parse("true && 1 < 2"))93        self.assertTrue(parse("!(5 < 1)"))94        self.assertTrue(parse("'abc' < 'def'"))95        self.assertFalse(parse("1 < 1"))96        self.assertFalse(parse("'abc' < 'abc'"))97    def test_greater_than(self):98        """99        Test the > operator.100        """101        self.assertTrue(parse("2 > 1"))102        self.assertFalse(parse("2 > 3"))103        self.assertTrue(parse("false || (2 > 1)"))104        self.assertTrue(parse("2 > 1 && true"))105        self.assertTrue(parse("true && 2 > 1"))106        self.assertTrue(parse("!(1 > 5)"))107        self.assertTrue(parse("'def' > 'abc'"))108        self.assertFalse(parse("1 > 1"))109        self.assertFalse(parse("'abc' > 'abc'"))110    def test_lesser_or_equals_than(self):111        """112        Test the <= operator.113        """114        self.assertTrue(parse("1 <= 2"))115        self.assertFalse(parse("3 <= 2"))116        self.assertTrue(parse("false || (1 <= 2)"))117        self.assertTrue(parse("1 < 2 && true"))118        self.assertTrue(parse("true && 1 <= 2"))119        self.assertTrue(parse("!(5 <= 1)"))120        self.assertTrue(parse("'abc' <= 'def'"))121        self.assertTrue(parse("1 <= 1"))122        self.assertTrue(parse("'abc' <= 'abc'"))123    def test_greater_or_equals_than(self):124        """125        Test the > operator.126        """127        self.assertTrue(parse("2 >= 1"))128        self.assertFalse(parse("2 >= 3"))129        self.assertTrue(parse("false || (2 >= 1)"))130        self.assertTrue(parse("2 >= 1 && true"))131        self.assertTrue(parse("true && 2 >= 1"))132        self.assertTrue(parse("!(1 >= 5)"))133        self.assertTrue(parse("'def' >= 'abc'"))134        self.assertTrue(parse("1 >= 1"))135        self.assertTrue(parse("'abc' >= 'abc'"))136if __name__ == '__main__':...

Full Screen

Full Screen

Using AI Code Generation

copy

Full Screen

1describe('Test Suite', function() {2  it('Test Case', function() {3    cy.fixture('example.json').then((file) => {4      cy.get('#file-upload').upload({ fileContent: file, fileName: 'example.json', mimeType: 'application/json' })5    })6  })7})8Cypress.Commands.add('upload', { prevSubject: 'element' }, (subject, options) => {9  cy.window().then((win) => {10    const testFile = new win.File([options.fileContent], options.fileName, { type: options.mimeType })11    const dataTransfer = new win.DataTransfer()12    dataTransfer.items.add(testFile)13    cy.wrap(subject).trigger('change', { force: true })14  })15})16{17}18{19}20describe('Test Suite', function() {21  it('Test Case', function() {22    cy.get('#file-upload').upload('example.json', 'application/json')23  })24})25Cypress.Commands.add('upload', { prevSubject: 'element' }, (subject, fileName, mimeType) => {26  cy.fixture(fileName, 'base64').then((content) => {27    cy.window().then((win) => {28      const testFile = new win.File([content], fileName, { type: mimeType })29      const dataTransfer = new win.DataTransfer()30      dataTransfer.items.add(testFile)31      cy.wrap(subject).trigger('change', { force: true })32    })33  })34})35{36}37{38}39describe('Test Suite', function() {40  it('Test Case', function() {

Full Screen

Full Screen

Using AI Code Generation

copy

Full Screen

1Cypress.parse('{"name": "John"}')2Cypress.stringify({name: 'John'})3Cypress.log({name: 'John'})4Cypress.wrap('John')5Cypress.minilog('John')6Cypress.now()

Full Screen

Full Screen

Using AI Code Generation

copy

Full Screen

1cy.get('input').invoke('val').then((val) => {2  const parsed = JSON.parse(val);3  expect(parsed).to.deep.equal({ a: 1, b: 2 });4});5const parsed = JSON.parse(cy.get('input').invoke('val'));6expect(parsed).to.deep.equal({ a: 1, b: 2 });7The above code is an example of how to use JSON.parse() method of JavaScript to parse the JSON string from a text field. We have used the .invoke() method of Cypress to get the value of the input field and then used the

Full Screen

Full Screen

Using AI Code Generation

copy

Full Screen

1var $ = Cypress.$;2var str = '<div id="div1"><span id="span1">Hello</span></div>';3var html = $.parseHTML(str);4console.log(html);5var str = '<div id="div1"><span id="span1">Hello</span></div>';6var html = jQuery.parseHTML(str);7console.log(html);8[div#div1, prevObject: init(1), context: document, selector: ""]9[div#div1, prevObject: init(1), context: document, selector: ""]

Full Screen

Full Screen

Using AI Code Generation

copy

Full Screen

1const parse = require('csv-parse/lib/sync')2const records = parse(file, {columns: true})3records.forEach((record) => {4it('should do something', () => {5cy.get('input[name="name"]').type(record.name)6cy.get('input[name="email"]').type(record.email)7})8})

Full Screen

Full Screen

Cypress Tutorial

Cypress is a renowned Javascript-based open-source, easy-to-use end-to-end testing framework primarily used for testing web applications. Cypress is a relatively new player in the automation testing space and has been gaining much traction lately, as evidenced by the number of Forks (2.7K) and Stars (42.1K) for the project. LambdaTest’s Cypress Tutorial covers step-by-step guides that will help you learn from the basics till you run automation tests on LambdaTest.

Chapters:

  1. What is Cypress? -
  2. Why Cypress? - Learn why Cypress might be a good choice for testing your web applications.
  3. Features of Cypress Testing - Learn about features that make Cypress a powerful and flexible tool for testing web applications.
  4. Cypress Drawbacks - Although Cypress has many strengths, it has a few limitations that you should be aware of.
  5. Cypress Architecture - Learn more about Cypress architecture and how it is designed to be run directly in the browser, i.e., it does not have any additional servers.
  6. Browsers Supported by Cypress - Cypress is built on top of the Electron browser, supporting all modern web browsers. Learn browsers that support Cypress.
  7. Selenium vs Cypress: A Detailed Comparison - Compare and explore some key differences in terms of their design and features.
  8. Cypress Learning: Best Practices - Take a deep dive into some of the best practices you should use to avoid anti-patterns in your automation tests.
  9. How To Run Cypress Tests on LambdaTest? - Set up a LambdaTest account, and now you are all set to learn how to run Cypress tests.

Certification

You can elevate your expertise with end-to-end testing using the Cypress automation framework and stay one step ahead in your career by earning a Cypress certification. Check out our Cypress 101 Certification.

YouTube

Watch this 3 hours of complete tutorial to learn the basics of Cypress and various Cypress commands with the Cypress testing at LambdaTest.

Run Cypress 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