tests/regression.tc

   1 testcase "pathological O(n^2) behavior" {
   2   input "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
   3   output "x";
   4           s = x:: ManyA!
   5      ManyA =  ()
   6             | x:: A ManyA
   7           A = ()! ("a" & ManyAB)
   8     ManyAB = ()
   9             | "a" ManyAB
  10             | "b" ManyAB
  11
  12 }
  13
  14 testcase "another O(n^2) example, tickles different epsilon behaviors" {
  15   input "aaaa";
  16   output "x:{x:{x:{x}}}";
  17   s = x:: s A! | ()
  18   A = "a" & B
  19   B = () | B "a"
  20 }
  21
  22 testcase "unnamed" {
  23     input "aaaaa";
  24     s = A
  25     A = "a" s &~ "a" A
  26       | "a" A &~ "a" s
  27 }
  28
  29 testcase "unnamed" {
  30     input "ab c";
  31     output "1:{{a b} {c}}";
  32
  33     s     = ids
  34     ids   = "1":: id (" " ids &~ id ("":: ~[]*))
  35           | "2":: id (    ids &~ id ("":: ~[]*))
  36           | id
  37     id    = "":: [a-z]++
  38 }
  39
  40 testcase "unnamed" {
  41     input "ab c";
  42
  43     output "2:{{a} 1:{{b} {c}}}";
  44     output "1:{{a b} {c}}";
  45
  46     s     = ids
  47     ids   = "1":: id " " ids
  48           | "2":: id     ids
  49           | id
  50     id    = "":: [a-z]+
  51 }
  52
  53 testcase "unnamed" {
  54     input "aaabbbccc";
  55     output "ab";
  56
  57     s     = ab & dc
  58     ab    = ab:: a b
  59     dc    = dc:: d c
  60     a     = "a" a     | ()
  61     b     = "b" b "c" | ()
  62     c     = "c" c     | ()
  63     d     = "a" d "b" | ()
  64 }
  65
  66 testcase "unnamed" {
  67     input "aaabbbbccc";
  68
  69     s     = ab & dc
  70     ab    = ab:: a b
  71     dc    = dc:: d c
  72     a     = "a" a     | ()
  73     b     = "b" b "c" | ()
  74     c     = "c" c     | ()
  75     d     = "a" d "b" | ()
  76 }
  77
  78 testcase "unnamed" {
  79     input "aabb";
  80     output "xbx:{{a} abab:{a b} {b}}";
  81
  82     x     = ~[]
  83     s     = xbx:: ("":: x*) b ("":: x*)
  84     b     = abab:: [ab][ab]
  85          &~ ("aa"|"bb")
  86 }
  87
  88 testcase "unnamed" {
  89     input  "qxbambambam";
  90     output "bam:{a bam:{a bam:{a x}}}";
  91
  92     s   = "q" z
  93     z   = a z ^"bam"
  94         | ^"x"
  95     a   = a:: ()
  96 }
  97
  98 testcase "unnamed" {
  99     input  "baaaa";
 100     output "s2:{b0 a:{a:{epsilon}}}";
 101     output "b:{a:{a:{epsilon}} epsilon}";
 102     s   = s2:: b t
 103         | ^"b" t b
 104     t   = ^"a" t "a"
 105         | epsilon:: ()
 106     b   = b0:: "b"
 107         | epsilon:: ()
 108 }
 109
 110 testcase "unnamed" {
 111     input  "qaq";
 112     output "q:{a:{s1:{epsilon}}}";
 113
 114     s   = ^"q" x "q"
 115     x   = ^"a" a
 116         | epsilon:: ()
 117     a   = s1:: x
 118 }
 119
 120 testcase "unnamed" {
 121     input "baa";
 122     output "s1:{a2:{a2:{a0 b0} b0}}";
 123
 124     s   = s1:: "b" a
 125     a   = a2:: "a" a b
 126         | a0:: ()
 127     b   = b0:: ()
 128 }
 129
 130 testcase "epsilon forests" {
 131     input  "aaa";
 132
 133     output "s3:{s3:{epsilon a0 epsilon epsilon} epsilon epsilon epsilon}";
 134     output "s3:{s3:{epsilon epsilon epsilon epsilon} a0 epsilon epsilon}";
 135     output "s3:{s3:{epsilon epsilon a0 epsilon} epsilon epsilon epsilon}";
 136     output "s3:{s3:{epsilon epsilon epsilon a0} epsilon epsilon epsilon}";
 137     output "s3:{epsilon epsilon a0 a0}";
 138     output "s3:{s3:{s3:{epsilon epsilon epsilon epsilon} epsilon epsilon epsilon} epsilon epsilon epsilon}";
 139     output "s3:{s3:{epsilon epsilon epsilon epsilon} epsilon epsilon a0}";
 140     output "s3:{s3:{epsilon epsilon epsilon epsilon} epsilon a0 epsilon}";
 141     output "s3:{epsilon a0 epsilon a0}";
 142     output "s3:{epsilon a0 a0 epsilon}";
 143
 144     s   = s3:: "a" s a a a
 145         | epsilon:: ()
 146     a   = a0:: "a"
 147         | epsilon:: ()
 148 }
 149
 150 testcase "unnamed" {
 151     input "aa";
 152     output "poo:{poo:{poox poox} poox}";
 153     output "poo:{poox poo:{poox poox}}";
 154     s   = poo::  s s "a"
 155         | poox:: ()
 156 }
 157
 158 testcase "unnamed" {
 159     input "baa";
 160     output "s:{aa:{aa:{a b} b}}";
 161     s   = s:: "b" a
 162     a   = aa:: "a" a b
 163         | a:: ()
 164     b   = b:: ()
 165 }
 166
 167 testcase "unnamed" {
 168     input "aaab";
 169     output "sx:{b aa:{aa:{b b} b}}";
 170     s   = sx:: b d "a" "b"
 171         | sy:: "a" d "a" d
 172     d   = aa:: "a" a b
 173     a   = aa:: "a" b b
 174         | a::  ()
 175     b   = b::  ()
 176 }
 177
 178 testcase "a+(b*c)" {
 179     input "a+(b*c)";
 180     output "+:{{a} *:{{b} {c}}}";
 181
 182     s     = r
 183     r     = id
 184           | r ^"*" r
 185           | r ^"+" r
 186           | "(" r ")"
 187     id    = "":: [a-z]++
 188 }
 189
 190 testcase "a+b-d*c" {
 191     input "a+b-d*c";
 192     output "times:{plus:{stringify:{a} minus:{stringify:{b} stringify:{d}}} stringify:{c}}";
 193     output "plus:{stringify:{a} times:{minus:{stringify:{b} stringify:{d}} stringify:{c}}}";
 194     output "minus:{plus:{stringify:{a} stringify:{b}} times:{stringify:{d} stringify:{c}}}";
 195     output "plus:{stringify:{a} minus:{stringify:{b} times:{stringify:{d} stringify:{c}}}}";
 196     output "times:{minus:{plus:{stringify:{a} stringify:{b}} stringify:{d}} stringify:{c}}";
 197     w    = " "
 198     l    = id
 199     s    = assign:: l "=" q
 200          | q
 201     q    = id
 202          | assign:: l "=" q
 203          | minus:: q "-" q
 204          | plus:: q "+" q
 205          | times:: q "*" q
 206          | "(" q ")"
 207     id     = stringify:: idl++
 208     idl    = [a-d]
 209 }
 210
 211 testcase "a+b*c" {
 212     input "a+b*c";
 213     output "plus:{stringify:{a} times:{stringify:{b} stringify:{c}}}";
 214     w    = " "
 215     l    = id
 216     s    = assign:: l "=" r
 217          | r
 218     r    = l
 219          | assign:: l "=" r
 220          | plus:: r "+" r
 221          > times:: r "*" r
 222          | "(" r ")"
 223          | times:: r r
 224     id     = stringify:: idl++
 225     idl    = [a-d]
 226 }
 227
 228 testcase "unnamed" {
 229   input "aa bb";
 230   output "{q:{a a} q:{b b}}";
 231
 232   s    = "":: q */ ws
 233   ws   = " "*
 234   q    = q:: [a-z]++
 235 }
 236
 237 testcase "indentation" {
 238
 239     input "
 240
 241
 242
 243  while x>0
 244     while y>0
 245        foo()
 246           bar()
 247
 248
 249  while x>0
 250     while y>0
 251           foo()
 252         bar()
 253
 254
 255
 256 ";
 257   output "smt:{while:{>:{{x} {0}} while:{>:{{y} {0}} sbb:{{f o o} {b a r}}}} while:{>:{{x} {0}} sbb:{while:{>:{{y} {0}} {f o o}} {b a r}}}}";
 258
 259 indent    = ww
 260 outdent   = " "  outdent " "
 261           | " "  ("":: (~[])*)  "\n"
 262
 263 w          = " " | "\n" | "\r"
 264 ws         = "":: w*
 265 ww         = "":: sp*
 266 sp         = " "
 267 any        = "":: (~[])*
 268
 269 s          = smt:: ws! statement ws! statement ws!
 270
 271 block       =        "\n" indent!  blockBody
 272            &~        "\n" (" " outdent! " ") ~[\ ]! ("":: ~[]*)!
 273
 274 blockBody   =       statement
 275             > sbb:: statement ws blockBody
 276
 277 statement   = call
 278             | ^"while" expr block /ws
 279
 280 expr        = ident
 281             | call
 282             | expr ^">" expr   /ws
 283             | num
 284
 285 call        = expr "()"        /ws
 286
 287 num         = "":: [0-9]++
 288
 289 ident       = "":: [a-z]++ &~ keyword
 290 keyword     = "if" | "then" | "else" | "while"
 291
 292
 293
 294 }
 295
 296
 297 testcase "unnamed" {
 298     input "abc                         ";
 299
 300     s     = s2:: q " "*
 301     q     = a3:: [a-z] [a-z] [a-z]
 302          &~ ("":: ~[])! "b" ("":: ~[]*)!
 303 }
 304
 305 testcase "unnamed" {
 306     input "abc                         ";
 307     output "s:{a b c}";
 308
 309     s     = s:: [a-z] [a-z] [a-z] " "*
 310 }
 311
 312 testcase "a+2" {
 313
 314     input "a+2";
 315     output "Plus:{left:{Foo} right:{{2}}}";
 316
 317     s       = Expr
 318     Expr    = "":: [0-9]++
 319             | Plus:: (left::Expra) "+" (right::Expr)
 320     Expra   = Foo:: ("a" | "b")
 321
 322 }
 323
 324 testcase "unnamed" {
 325     input "aaaaa";
 326     output "top:{a q:{a a a} a}";
 327
 328     s = top:: z (q::"a"*) z
 329     z = a:: "a"
 330 }
 331
 332 testcase "dangling else" {
 333     input  "if (x) if (y) z else q";
 334     output "if:{ident:{x} else:{if:{ident:{y} then:{ident:{z}}} ident:{q}}}";
 335
 336     s      = Expr
 337     Expr   = if::     "if" "(" Expr ")" IfBody     /ws
 338            | ident::  [a-z]++
 339     IfBody = else::   Expr            "else"  Expr /ws
 340            | then::   Expr &~   (("":: (~[])*) "else" Expr! /ws)
 341     ws     = "":: [ ]**
 342 }
 343
 344
 345 testcase "unnamed" {
 346     input "12111211";
 347     output "ac:{{2 1 2 1}}";
 348
 349     s   = ab:: ab
 350         | ac:: ac
 351         | bc:: bc
 352     ab   = a & b
 353     ac   = a & c
 354     bc   = b & c
 355     a   = "":: ("1" x)*
 356     b   = "":: ("b":: x "2")*
 357     c   = "":: ("c":: x "2" x "1")*
 358     x   = [123]
 359 }
 360
 361 testcase "follow restrictions on empty string" {
 362   input "xxx";
 363   s = x:: "x" A "x" C "x"
 364   A = B
 365   B = "y"
 366     | () -> ~"x"
 367   C = D -> ~"x"
 368   D = ()
 369 }
 370
 371 testcase "unnamed" {
 372   input "axxxxxc";
 373   output "q:{a {x x x x x} c}";
 374   s  = q:: A ws (B|()) ws C
 375   ws = "":: [x]**
 376   A  = a:: "a"
 377   B  = b:: "b"
 378   C  = c:: "c"
 379 }
 380
 381 testcase "unnamed" {
 382   input "aaaaaaaaaaaaaaaaaaaa";
 383   output "";
 384   s = As & AAs
 385   As = () | As "a"
 386   AAs = () | AAs "aa"
 387 }