extra/infix/parser/parser-tests.factor

   1 ! Copyright (C) 2009 Philipp Brüschweiler
   2 ! See http://factorcode.org/license.txt for BSD license.
   3 USING: infix.ast infix.parser infix.tokenizer tools.test ;
   4 IN: infix.parser.tests
   5
   6 { T{ ast-number { value 1 } } } [ "1" build-infix-ast ] unit-test
   7 { T{ ast-negation f T{ ast-number { value 1 } } } }
   8 [ "-1" build-infix-ast ] unit-test
   9 { T{ ast-op
  10     { left
  11         T{ ast-op
  12             { left T{ ast-number { value 1 } } }
  13             { right T{ ast-number { value 2 } } }
  14             { op "+" }
  15         }
  16     }
  17     { right T{ ast-number { value 4 } } }
  18     { op "+" }
  19 } } [ "1+2+4" build-infix-ast ] unit-test
  20
  21 { T{ ast-op
  22     { left T{ ast-number { value 1 } } }
  23     { right
  24         T{ ast-op
  25             { left T{ ast-number { value 2 } } }
  26             { right T{ ast-number { value 3 } } }
  27             { op "*" }
  28         }
  29     }
  30     { op "+" }
  31 } } [ "1+2*3" build-infix-ast ] unit-test
  32
  33 { T{ ast-op
  34     { left T{ ast-number { value 1 } } }
  35     { right T{ ast-number { value 2 } } }
  36     { op "+" }
  37 } } [ "(1+2)" build-infix-ast ] unit-test
  38
  39 { T{ ast-local { name "foo" } } } [ "foo" build-infix-ast ] unit-test
  40 [ "-" build-infix-ast ] must-fail
  41
  42 { T{ ast-function
  43     { name "foo" }
  44     { arguments
  45         V{
  46             T{ ast-op
  47                 { left T{ ast-number { value 1 } } }
  48                 { right T{ ast-number { value 2 } } }
  49                 { op "+" }
  50             }
  51             T{ ast-op
  52                 { left T{ ast-number { value 2 } } }
  53                 { right T{ ast-number { value 3 } } }
  54                 { op "%" }
  55             }
  56         }
  57     }
  58 } } [ "foo (1+ 2,2%3)  " build-infix-ast ] unit-test
  59
  60 { T{ ast-op
  61     { left
  62         T{ ast-op
  63             { left
  64                 T{ ast-function
  65                     { name "bar" }
  66                     { arguments V{ } }
  67                 }
  68             }
  69             { right
  70                 T{ ast-array
  71                     { name "baz" }
  72                     { index
  73                         T{ ast-op
  74                             { left
  75                                 T{ ast-op
  76                                     { left
  77                                         T{ ast-number
  78                                             { value 2 }
  79                                         }
  80                                     }
  81                                     { right
  82                                         T{ ast-number
  83                                             { value 3 }
  84                                         }
  85                                     }
  86                                     { op "/" }
  87                                 }
  88                             }
  89                             { right
  90                                 T{ ast-number { value 4 } }
  91                             }
  92                             { op "+" }
  93                         }
  94                     }
  95                 }
  96             }
  97             { op "+" }
  98         }
  99     }
 100     { right T{ ast-number { value 2 } } }
 101     { op "/" }
 102 } } [ "(bar() + baz[2/ 3+4 ] )/2" build-infix-ast ] unit-test
 103
 104 { T{ ast-op
 105     { left T{ ast-number { value 1 } } }
 106     { right
 107         T{ ast-op
 108             { left T{ ast-number { value 2 } } }
 109             { right T{ ast-number { value 3 } } }
 110             { op "/" }
 111         }
 112     }
 113     { op "+" }
 114 } } [ "1\n+\n2\r/\t3" build-infix-ast ] unit-test
 115
 116 { T{ ast-negation
 117     { term
 118         T{ ast-function
 119             { name "foo" }
 120             { arguments
 121                 V{
 122                     T{ ast-number { value 2 } }
 123                     T{ ast-negation
 124                         { term T{ ast-number { value 3 } } }
 125                     }
 126                 }
 127             }
 128         }
 129     }
 130 } } [ "-foo(+2,-3)" build-infix-ast ] unit-test
 131
 132 { T{ ast-array
 133     { name "arr" }
 134     { index
 135         T{ ast-op
 136             { left
 137                 T{ ast-negation
 138                     { term
 139                         T{ ast-op
 140                             { left
 141                                 T{ ast-function
 142                                     { name "foo" }
 143                                     { arguments
 144                                         V{
 145                                             T{ ast-number
 146                                                 { value 2 }
 147                                             }
 148                                         }
 149                                     }
 150                                 }
 151                             }
 152                             { right
 153                                 T{ ast-negation
 154                                     { term
 155                                         T{ ast-number
 156                                             { value 1 }
 157                                         }
 158                                     }
 159                                 }
 160                             }
 161                             { op "+" }
 162                         }
 163                     }
 164                 }
 165             }
 166             { right T{ ast-number { value 3 } } }
 167             { op "/" }
 168         }
 169     }
 170 } } [ "+arr[-(foo(2)+-1)/3]" build-infix-ast ] unit-test
 171
 172 [ "foo bar baz" build-infix-ast ] must-fail
 173 [ "1+2/4+" build-infix-ast ] must-fail
 174 [ "quaz(2/3,)" build-infix-ast ] must-fail