| OLD | NEW |
|---|
| (Empty) |
| 1 library petitparser.test.smalltalk_test; | |
| 2 | |
| 3 import 'package:test/test.dart'; | |
| 4 | |
| 5 import 'package:petitparser/smalltalk.dart'; | |
| 6 | |
| 7 var definition = new SmalltalkGrammarDefinition(); | |
| 8 | |
| 9 dynamic validate(String source, Function production) { | |
| 10 var parser = definition.build(start: production).end(); | |
| 11 var result = parser.parse(source); | |
| 12 return result.value; | |
| 13 } | |
| 14 | |
| 15 void main() { | |
| 16 test('testArray1', () { | |
| 17 return validate('{}', definition.array); | |
| 18 }); | |
| 19 test('testArray2', () { | |
| 20 return validate('{self foo}', definition.array); | |
| 21 }); | |
| 22 test('testArray3', () { | |
| 23 return validate('{self foo. self bar}', definition.array); | |
| 24 }); | |
| 25 test('testArray4', () { | |
| 26 return validate('{self foo. self bar.}', definition.array); | |
| 27 }); | |
| 28 test('testAssignment1', () { | |
| 29 return validate('1', definition.expression); | |
| 30 }); | |
| 31 test('testAssignment2', () { | |
| 32 return validate('a := 1', definition.expression); | |
| 33 }); | |
| 34 test('testAssignment3', () { | |
| 35 return validate('a := b := 1', definition.expression); | |
| 36 }); | |
| 37 test('testAssignment6', () { | |
| 38 return validate('a := (b := c)', definition.expression); | |
| 39 }); | |
| 40 test('testComment1', () { | |
| 41 return validate('1"one"+2', definition.expression); | |
| 42 }); | |
| 43 test('testComment2', () { | |
| 44 return validate('1 "one" +2', definition.expression); | |
| 45 }); | |
| 46 test('testComment3', () { | |
| 47 return validate('1"one"+"two"2', definition.expression); | |
| 48 }); | |
| 49 test('testComment4', () { | |
| 50 return validate('1"one""two"+2', definition.expression); | |
| 51 }); | |
| 52 test('testComment5', () { | |
| 53 return validate('1"one" "two"+2', definition.expression); | |
| 54 }); | |
| 55 test('testMethod1', () { | |
| 56 return validate('negated ^ 0 - self', definition.method); | |
| 57 }); | |
| 58 test('testMethod2', () { | |
| 59 return validate(' negated ^ 0 - self', definition.method); | |
| 60 }); | |
| 61 test('testMethod3', () { | |
| 62 return validate(' negated ^ 0 - self ', definition.method); | |
| 63 }); | |
| 64 test('testSequence1', () { | |
| 65 return validate('| a | 1 . 2', definition.sequence); | |
| 66 }); | |
| 67 test('testStatements1', () { | |
| 68 return validate('1', definition.sequence); | |
| 69 }); | |
| 70 test('testStatements2', () { | |
| 71 return validate('1 . 2', definition.sequence); | |
| 72 }); | |
| 73 test('testStatements3', () { | |
| 74 return validate('1 . 2 . 3', definition.sequence); | |
| 75 }); | |
| 76 test('testStatements4', () { | |
| 77 return validate('1 . 2 . 3 .', definition.sequence); | |
| 78 }); | |
| 79 test('testStatements5', () { | |
| 80 return validate('1 . . 2', definition.sequence); | |
| 81 }); | |
| 82 test('testStatements6', () { | |
| 83 return validate('1. 2', definition.sequence); | |
| 84 }); | |
| 85 test('testStatements7', () { | |
| 86 return validate('. 1', definition.sequence); | |
| 87 }); | |
| 88 test('testStatements8', () { | |
| 89 return validate('.1', definition.sequence); | |
| 90 }); | |
| 91 test('testTemporaries1', () { | |
| 92 return validate('| a |', definition.sequence); | |
| 93 }); | |
| 94 test('testTemporaries2', () { | |
| 95 return validate('| a b |', definition.sequence); | |
| 96 }); | |
| 97 test('testTemporaries3', () { | |
| 98 return validate('| a b c |', definition.sequence); | |
| 99 }); | |
| 100 test('testVariable1', () { | |
| 101 return validate('trueBinding', definition.primary); | |
| 102 }); | |
| 103 test('testVariable2', () { | |
| 104 return validate('falseBinding', definition.primary); | |
| 105 }); | |
| 106 test('testVariable3', () { | |
| 107 return validate('nilly', definition.primary); | |
| 108 }); | |
| 109 test('testVariable4', () { | |
| 110 return validate('selfish', definition.primary); | |
| 111 }); | |
| 112 test('testVariable5', () { | |
| 113 return validate('supernanny', definition.primary); | |
| 114 }); | |
| 115 test('testVariable6', () { | |
| 116 return validate('super_nanny', definition.primary); | |
| 117 }); | |
| 118 test('testVariable7', () { | |
| 119 return validate('__gen_var_123__', definition.primary); | |
| 120 }); | |
| 121 test('testArgumentsBlock1', () { | |
| 122 return validate('[ :a | ]', definition.block); | |
| 123 }); | |
| 124 test('testArgumentsBlock2', () { | |
| 125 return validate('[ :a :b | ]', definition.block); | |
| 126 }); | |
| 127 test('testArgumentsBlock3', () { | |
| 128 return validate('[ :a :b :c | ]', definition.block); | |
| 129 }); | |
| 130 test('testComplexBlock1', () { | |
| 131 return validate('[ :a | | b | c ]', definition.block); | |
| 132 }); | |
| 133 test('testComplexBlock2', () { | |
| 134 return validate('[:a||b|c]', definition.block); | |
| 135 }); | |
| 136 test('testSimpleBlock1', () { | |
| 137 return validate('[ ]', definition.block); | |
| 138 }); | |
| 139 test('testSimpleBlock2', () { | |
| 140 return validate('[ nil ]', definition.block); | |
| 141 }); | |
| 142 test('testSimpleBlock3', () { | |
| 143 return validate('[ :a ]', definition.block); | |
| 144 }); | |
| 145 test('testStatementBlock1', () { | |
| 146 return validate('[ nil ]', definition.block); | |
| 147 }); | |
| 148 test('testStatementBlock2', () { | |
| 149 return validate('[ | a | nil ]', definition.block); | |
| 150 }); | |
| 151 test('testStatementBlock3', () { | |
| 152 return validate('[ | a b | nil ]', definition.block); | |
| 153 }); | |
| 154 test('testArrayLiteral1', () { | |
| 155 return validate('#()', definition.arrayLiteral); | |
| 156 }); | |
| 157 test('testArrayLiteral10', () { | |
| 158 return validate('#((1 2) #(1 2 3))', definition.arrayLiteral); | |
| 159 }); | |
| 160 test('testArrayLiteral11', () { | |
| 161 return validate('#([1 2] #[1 2 3])', definition.arrayLiteral); | |
| 162 }); | |
| 163 test('testArrayLiteral2', () { | |
| 164 return validate('#(1)', definition.arrayLiteral); | |
| 165 }); | |
| 166 test('testArrayLiteral3', () { | |
| 167 return validate('#(1 2)', definition.arrayLiteral); | |
| 168 }); | |
| 169 test('testArrayLiteral4', () { | |
| 170 return validate('#(true false nil)', definition.arrayLiteral); | |
| 171 }); | |
| 172 test('testArrayLiteral5', () { | |
| 173 return validate('#(\$a)', definition.arrayLiteral); | |
| 174 }); | |
| 175 test('testArrayLiteral6', () { | |
| 176 return validate('#(1.2)', definition.arrayLiteral); | |
| 177 }); | |
| 178 test('testArrayLiteral7', () { | |
| 179 return validate('#(size #at: at:put: #' '==' ')', definition.arrayLiteral); | |
| 180 }); | |
| 181 test('testArrayLiteral8', () { | |
| 182 return validate('#(' 'baz' ')', definition.arrayLiteral); | |
| 183 }); | |
| 184 test('testArrayLiteral9', () { | |
| 185 return validate('#((1) 2)', definition.arrayLiteral); | |
| 186 }); | |
| 187 test('testByteLiteral1', () { | |
| 188 return validate('#[]', definition.byteLiteral); | |
| 189 }); | |
| 190 test('testByteLiteral2', () { | |
| 191 return validate('#[0]', definition.byteLiteral); | |
| 192 }); | |
| 193 test('testByteLiteral3', () { | |
| 194 return validate('#[255]', definition.byteLiteral); | |
| 195 }); | |
| 196 test('testByteLiteral4', () { | |
| 197 return validate('#[ 1 2 ]', definition.byteLiteral); | |
| 198 }); | |
| 199 test('testByteLiteral5', () { | |
| 200 return validate('#[ 2r1010 8r77 16rFF ]', definition.byteLiteral); | |
| 201 }); | |
| 202 test('testCharLiteral1', () { | |
| 203 return validate('\$a', definition.characterLiteral); | |
| 204 }); | |
| 205 test('testCharLiteral2', () { | |
| 206 return validate('\$ ', definition.characterLiteral); | |
| 207 }); | |
| 208 test('testCharLiteral3', () { | |
| 209 return validate('\$\$', definition.characterLiteral); | |
| 210 }); | |
| 211 test('testNumberLiteral1', () { | |
| 212 return validate('0', definition.numberLiteral); | |
| 213 }); | |
| 214 test('testNumberLiteral10', () { | |
| 215 return validate('10r10', definition.numberLiteral); | |
| 216 }); | |
| 217 test('testNumberLiteral11', () { | |
| 218 return validate('8r777', definition.numberLiteral); | |
| 219 }); | |
| 220 test('testNumberLiteral12', () { | |
| 221 return validate('16rAF', definition.numberLiteral); | |
| 222 }); | |
| 223 test('testNumberLiteral2', () { | |
| 224 return validate('0.1', definition.numberLiteral); | |
| 225 }); | |
| 226 test('testNumberLiteral3', () { | |
| 227 return validate('123', definition.numberLiteral); | |
| 228 }); | |
| 229 test('testNumberLiteral4', () { | |
| 230 return validate('123.456', definition.numberLiteral); | |
| 231 }); | |
| 232 test('testNumberLiteral5', () { | |
| 233 return validate('-0', definition.numberLiteral); | |
| 234 }); | |
| 235 test('testNumberLiteral6', () { | |
| 236 return validate('-0.1', definition.numberLiteral); | |
| 237 }); | |
| 238 test('testNumberLiteral7', () { | |
| 239 return validate('-123', definition.numberLiteral); | |
| 240 }); | |
| 241 test('testNumberLiteral8', () { | |
| 242 return validate('-123', definition.numberLiteral); | |
| 243 }); | |
| 244 test('testNumberLiteral9', () { | |
| 245 return validate('-123.456', definition.numberLiteral); | |
| 246 }); | |
| 247 test('testSpecialLiteral1', () { | |
| 248 return validate('true', definition.trueLiteral); | |
| 249 }); | |
| 250 test('testSpecialLiteral2', () { | |
| 251 return validate('false', definition.falseLiteral); | |
| 252 }); | |
| 253 test('testSpecialLiteral3', () { | |
| 254 return validate('nil', definition.nilLiteral); | |
| 255 }); | |
| 256 test('testStringLiteral1', () { | |
| 257 return validate('\'\'', definition.stringLiteral); | |
| 258 }); | |
| 259 test('testStringLiteral2', () { | |
| 260 return validate('\'ab\'', definition.stringLiteral); | |
| 261 }); | |
| 262 test('testStringLiteral3', () { | |
| 263 return validate('\'ab\'\'cd\'', definition.stringLiteral); | |
| 264 }); | |
| 265 test('testSymbolLiteral1', () { | |
| 266 return validate('#foo', definition.symbolLiteral); | |
| 267 }); | |
| 268 test('testSymbolLiteral2', () { | |
| 269 return validate('#+', definition.symbolLiteral); | |
| 270 }); | |
| 271 test('testSymbolLiteral3', () { | |
| 272 return validate('#key:', definition.symbolLiteral); | |
| 273 }); | |
| 274 test('testSymbolLiteral4', () { | |
| 275 return validate('#key:value:', definition.symbolLiteral); | |
| 276 }); | |
| 277 test('testSymbolLiteral5', () { | |
| 278 return validate('#\'testing-result\'', definition.symbolLiteral); | |
| 279 }); | |
| 280 test('testSymbolLiteral6', () { | |
| 281 return validate('#__gen__binding', definition.symbolLiteral); | |
| 282 }); | |
| 283 test('testSymbolLiteral7', () { | |
| 284 return validate('# fucker', definition.symbolLiteral); | |
| 285 }); | |
| 286 test('testSymbolLiteral8', () { | |
| 287 return validate('##fucker', definition.symbolLiteral); | |
| 288 }); | |
| 289 test('testSymbolLiteral9', () { | |
| 290 return validate('## fucker', definition.symbolLiteral); | |
| 291 }); | |
| 292 test('testBinaryExpression1', () { | |
| 293 return validate('1 + 2', definition.expression); | |
| 294 }); | |
| 295 test('testBinaryExpression2', () { | |
| 296 return validate('1 + 2 + 3', definition.expression); | |
| 297 }); | |
| 298 test('testBinaryExpression3', () { | |
| 299 return validate('1 // 2', definition.expression); | |
| 300 }); | |
| 301 test('testBinaryExpression4', () { | |
| 302 return validate('1 -- 2', definition.expression); | |
| 303 }); | |
| 304 test('testBinaryExpression5', () { | |
| 305 return validate('1 ==> 2', definition.expression); | |
| 306 }); | |
| 307 test('testBinaryMethod1', () { | |
| 308 return validate('+ a', definition.method); | |
| 309 }); | |
| 310 test('testBinaryMethod2', () { | |
| 311 return validate('+ a | b |', definition.method); | |
| 312 }); | |
| 313 test('testBinaryMethod3', () { | |
| 314 return validate('+ a b', definition.method); | |
| 315 }); | |
| 316 test('testBinaryMethod4', () { | |
| 317 return validate('+ a | b | c', definition.method); | |
| 318 }); | |
| 319 test('testBinaryMethod5', () { | |
| 320 return validate('-- a', definition.method); | |
| 321 }); | |
| 322 test('testCascadeExpression1', () { | |
| 323 return validate('1 abs; negated', definition.expression); | |
| 324 }); | |
| 325 test('testCascadeExpression2', () { | |
| 326 return validate( | |
| 327 '1 abs negated; raisedTo: 12; negated', definition.expression); | |
| 328 }); | |
| 329 test('testCascadeExpression3', () { | |
| 330 return validate('1 + 2; - 3', definition.expression); | |
| 331 }); | |
| 332 test('testKeywordExpression1', () { | |
| 333 return validate('1 to: 2', definition.expression); | |
| 334 }); | |
| 335 test('testKeywordExpression2', () { | |
| 336 return validate('1 to: 2 by: 3', definition.expression); | |
| 337 }); | |
| 338 test('testKeywordExpression3', () { | |
| 339 return validate('1 to: 2 by: 3 do: 4', definition.expression); | |
| 340 }); | |
| 341 test('testKeywordMethod1', () { | |
| 342 return validate('to: a', definition.method); | |
| 343 }); | |
| 344 test('testKeywordMethod2', () { | |
| 345 return validate('to: a do: b | c |', definition.method); | |
| 346 }); | |
| 347 test('testKeywordMethod3', () { | |
| 348 return validate('to: a do: b by: c d', definition.method); | |
| 349 }); | |
| 350 test('testKeywordMethod4', () { | |
| 351 return validate('to: a do: b by: c | d | e', definition.method); | |
| 352 }); | |
| 353 test('testUnaryExpression1', () { | |
| 354 return validate('1 abs', definition.expression); | |
| 355 }); | |
| 356 test('testUnaryExpression2', () { | |
| 357 return validate('1 abs negated', definition.expression); | |
| 358 }); | |
| 359 test('testUnaryMethod1', () { | |
| 360 return validate('abs', definition.method); | |
| 361 }); | |
| 362 test('testUnaryMethod2', () { | |
| 363 return validate('abs | a |', definition.method); | |
| 364 }); | |
| 365 test('testUnaryMethod3', () { | |
| 366 return validate('abs a', definition.method); | |
| 367 }); | |
| 368 test('testUnaryMethod4', () { | |
| 369 return validate('abs | a | b', definition.method); | |
| 370 }); | |
| 371 test('testUnaryMethod5', () { | |
| 372 return validate('abs | a |', definition.method); | |
| 373 }); | |
| 374 test('testPragma1', () { | |
| 375 return validate('method <foo>', definition.method); | |
| 376 }); | |
| 377 test('testPragma10', () { | |
| 378 return validate('method <foo: bar>', definition.method); | |
| 379 }); | |
| 380 test('testPragma11', () { | |
| 381 return validate('method <foo: true>', definition.method); | |
| 382 }); | |
| 383 test('testPragma12', () { | |
| 384 return validate('method <foo: false>', definition.method); | |
| 385 }); | |
| 386 test('testPragma13', () { | |
| 387 return validate('method <foo: nil>', definition.method); | |
| 388 }); | |
| 389 test('testPragma14', () { | |
| 390 return validate('method <foo: ()>', definition.method); | |
| 391 }); | |
| 392 test('testPragma15', () { | |
| 393 return validate('method <foo: #()>', definition.method); | |
| 394 }); | |
| 395 test('testPragma16', () { | |
| 396 return validate('method < + 1 >', definition.method); | |
| 397 }); | |
| 398 test('testPragma2', () { | |
| 399 return validate('method <foo> <bar>', definition.method); | |
| 400 }); | |
| 401 test('testPragma3', () { | |
| 402 return validate('method | a | <foo>', definition.method); | |
| 403 }); | |
| 404 test('testPragma4', () { | |
| 405 return validate('method <foo> | a |', definition.method); | |
| 406 }); | |
| 407 test('testPragma5', () { | |
| 408 return validate('method <foo> | a | <bar>', definition.method); | |
| 409 }); | |
| 410 test('testPragma6', () { | |
| 411 return validate('method <foo: 1>', definition.method); | |
| 412 }); | |
| 413 test('testPragma7', () { | |
| 414 return validate('method <foo: 1.2>', definition.method); | |
| 415 }); | |
| 416 test('testPragma8', () { | |
| 417 return validate('method <foo: ' 'bar' '>', definition.method); | |
| 418 }); | |
| 419 test('testPragma9', () { | |
| 420 return validate('method <foo: #' 'bar' '>', definition.method); | |
| 421 }); | |
| 422 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2989763002:
Update charted to 0.4.8 and roll (Closed)
