rtext 0.9.0 → 0.9.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (17) hide show
  1. checksums.yaml +5 -5
  2. data/CHANGELOG +102 -98
  3. data/Rakefile +46 -46
  4. data/lib/rtext/default_completer.rb +212 -208
  5. data/lib/rtext/service.rb +264 -260
  6. data/test/completer_test.rb +606 -607
  7. data/test/context_builder_test.rb +948 -949
  8. data/test/frontend/context_test.rb +301 -302
  9. data/test/instantiator_test.rb +1732 -1733
  10. data/test/integration/frontend.log +401 -40039
  11. data/test/integration/test.rb +967 -968
  12. data/test/link_detector_test.rb +287 -288
  13. data/test/message_helper_test.rb +116 -117
  14. data/test/serializer_test.rb +1023 -1024
  15. data/test/tokenizer_test.rb +173 -174
  16. metadata +15 -17
  17. data/test/integration/backend.out +0 -16
data/test/instantiator_test.rb CHANGED
@@ -1,1733 +1,1732 @@
1
- # coding: binary
2
- $:.unshift File.join(File.dirname(__FILE__),"..","lib")
3
-
4
- gem 'minitest'
5
- require 'minitest/autorun'
6
- require 'bigdecimal'
7
- require 'rgen/environment'
8
- require 'rgen/metamodel_builder'
9
- require 'rtext/instantiator'
10
- require 'rtext/language'
11
-
12
- class InstantiatorTest < MiniTest::Test
13
-
14
- module TestMM
15
- extend RGen::MetamodelBuilder::ModuleExtension
16
- class TestNode < RGen::MetamodelBuilder::MMBase
17
- SomeEnum = RGen::MetamodelBuilder::DataTypes::Enum.new([:A, :B, :'non-word*chars', :'2you'])
18
- has_attr 'text', String
19
- has_attr 'integer', Integer
20
- has_attr 'boolean', Boolean
21
- has_attr 'enum', SomeEnum
22
- has_many_attr 'nums', Integer
23
- has_attr 'float', Float
24
- has_one 'related', TestNode
25
- has_many 'others', TestNode
26
- contains_many 'childs', TestNode, 'parent'
27
- end
28
- class SubNode < TestNode
29
- end
30
- end
31
-
32
- module TestMM2
33
- extend RGen::MetamodelBuilder::ModuleExtension
34
- class TestNode < RGen::MetamodelBuilder::MMBase
35
- contains_one 'singleChild', TestNode, 'parent'
36
- end
37
- class TestNode2 < RGen::MetamodelBuilder::MMBase
38
- end
39
- class TestNode3 < RGen::MetamodelBuilder::MMBase
40
- end
41
- class TestNode4 < TestNode
42
- end
43
- TestNode.contains_one 'singleChild2a', TestNode2, 'parentA'
44
- TestNode.contains_one 'singleChild2b', TestNode2, 'parentB'
45
- end
46
-
47
- module TestMMLinenoFilenameFragment
48
- extend RGen::MetamodelBuilder::ModuleExtension
49
- class TestNode < RGen::MetamodelBuilder::MMBase
50
- has_attr 'text', String
51
- has_attr 'lineno', Integer
52
- has_attr 'filename', String
53
- has_attr 'fragmentr', String
54
- contains_many 'childs', TestNode, 'parent'
55
- end
56
- end
57
-
58
- module TestMMAbstract
59
- extend RGen::MetamodelBuilder::ModuleExtension
60
- class TestNode < RGen::MetamodelBuilder::MMBase
61
- abstract
62
- end
63
- end
64
-
65
- module TestMMData
66
- extend RGen::MetamodelBuilder::ModuleExtension
67
- # class "Data" exists in the standard Ruby namespace
68
- class Data < RGen::MetamodelBuilder::MMBase
69
- has_attr 'notTheBuiltin', String
70
- end
71
- end
72
-
73
- module TestMMSubpackage
74
- extend RGen::MetamodelBuilder::ModuleExtension
75
- module SubPackage
76
- extend RGen::MetamodelBuilder::ModuleExtension
77
- class TestNodeSub < RGen::MetamodelBuilder::MMBase
78
- has_attr 'text', String
79
- end
80
- class Data < RGen::MetamodelBuilder::MMBase
81
- has_attr 'notTheBuiltin', String
82
- end
83
- end
84
- end
85
-
86
- module TestMMNonRootClass
87
- extend RGen::MetamodelBuilder::ModuleExtension
88
- class NonRootClass < RGen::MetamodelBuilder::MMBase
89
- end
90
- end
91
-
92
- module TestMMContextSensitiveCommands
93
- extend RGen::MetamodelBuilder::ModuleExtension
94
- module SubPackage2
95
- extend RGen::MetamodelBuilder::ModuleExtension
96
- class Command < RGen::MetamodelBuilder::MMBase
97
- end
98
- end
99
- module SubPackage1
100
- extend RGen::MetamodelBuilder::ModuleExtension
101
- class Command < RGen::MetamodelBuilder::MMBase
102
- contains_one 'command', SubPackage2::Command, 'super'
103
- end
104
- end
105
- class TestNode < RGen::MetamodelBuilder::MMBase
106
- contains_one 'command', SubPackage1::Command, 'testNode'
107
- end
108
- end
109
-
110
- def test_simple
111
- env, problems = instantiate(%Q(
112
- TestNode text: "some text", nums: [1,2] {
113
- TestNode text: "child"
114
- TestNode text: "child2"
115
- }
116
- ), TestMM)
117
- assert_no_problems(problems)
118
- assert_model_simple(env, :with_nums)
119
- end
120
-
121
- def test_multiple_roots
122
- env, problems = instantiate(%Q(
123
- TestNode
124
- TestNode
125
- ), TestMM)
126
- assert_no_problems(problems)
127
- assert_equal 2, env.elements.size
128
- end
129
-
130
- def test_comment
131
- env, problems = instantiate(%Q(
132
- # comment 1
133
- TestNode text: "some text" {# comment 1.1
134
- childs: [ # comment 1.2
135
- # comment 2
136
- TestNode text: "child" # comment 2.1
137
- # comment 3
138
- TestNode text: "child2" #comment 3.1
139
- # unassociated
140
- ] # comment 1.3
141
- # unassociated
142
- } # comment 1.4
143
- #comment 1
144
- TestNode { #comment 1.1
145
- childs: # comment 1.2
146
- TestNode text: "child" #comment2
147
- # unassociated
148
- }# comment 1.3
149
- # unassociated
150
- ), TestMM)
151
- assert_no_problems(problems)
152
- assert_model_simple(env)
153
- end
154
-
155
- def test_comment_only
156
- env, problems = instantiate(%Q(
157
- # comment 1
158
- ), TestMM)
159
- assert_no_problems(problems)
160
- end
161
-
162
- def test_empty
163
- env, problems = instantiate("", TestMM)
164
- assert_no_problems(problems)
165
- end
166
-
167
- #
168
- # options
169
- #
170
-
171
- def test_line_number_setter
172
- env, problems = instantiate(%q(
173
- TestNode text: "node1" {
174
- TestNode text: "node2"
175
-
176
- #some comment
177
- TestNode text: "node3"
178
- }
179
- TestNode text: "node4"
180
- ), TestMMLinenoFilenameFragment, :line_number_attribute => "lineno")
181
- assert_no_problems(problems)
182
- assert_equal 2, env.find(:text => "node1").first.lineno
183
- assert_equal 3, env.find(:text => "node2").first.lineno
184
- assert_equal 6, env.find(:text => "node3").first.lineno
185
- assert_equal 8, env.find(:text => "node4").first.lineno
186
- end
187
-
188
- def test_missing_line_number_setter
189
- env, problems = instantiate(%Q(
190
- TestNode text: A
191
- ), TestMMLinenoFilenameFragment, :line_number_attribute => "wrong_attribute_name")
192
- assert_no_problems(problems)
193
- assert_nil env.elements.first.lineno
194
- end
195
-
196
- def test_root_elements
197
- root_elements = []
198
- env, problems = instantiate(%Q(
199
- TestNode text: A
200
- TestNode text: B
201
- TestNode text: C
202
- ), TestMM, :root_elements => root_elements)
203
- assert_no_problems(problems)
204
- assert_equal ["A", "B", "C"], root_elements.text
205
- end
206
-
207
- def test_file_name_option
208
- env, problems = instantiate(%Q(
209
- TestNode text: A
210
- TestNode text: B
211
- TestNode a problem here
212
- ), TestMM, :file_name => "some_file")
213
- assert_equal "some_file", problems.first.file
214
- end
215
-
216
- def test_file_name_setter
217
- env, problems = instantiate(%Q(
218
- TestNode text: A
219
- ), TestMMLinenoFilenameFragment, :file_name => "some_file", :file_name_attribute => "filename")
220
- assert_equal "some_file", env.elements.first.filename
221
- end
222
-
223
- def test_missing_file_name_setter
224
- env, problems = instantiate(%Q(
225
- TestNode text: A
226
- ), TestMMLinenoFilenameFragment, :file_name => "some_file", :file_name_attribute => "wrong_attribute_name")
227
- assert_nil env.elements.first.filename
228
- end
229
-
230
- def test_fragment_ref_setter
231
- the_ref = "is a string here but would normally be an RGen fragment"
232
- env, problems = instantiate(%Q(
233
- TestNode text: A
234
- ), TestMMLinenoFilenameFragment, :fragment_ref => the_ref, :fragment_ref_attribute => "fragmentr")
235
- assert_equal the_ref.object_id, env.elements.first.fragmentr.object_id
236
- end
237
-
238
- def test_missing_fragment_ref_setter
239
- the_ref = "is a string here but would normally be an RGen fragment"
240
- env, problems = instantiate(%Q(
241
- TestNode text: A
242
- ), TestMMLinenoFilenameFragment, :fragment_ref => the_ref, :fragment_ref_attribute => "wrong_attribute_name")
243
- assert_nil env.elements.first.fragmentr
244
- end
245
-
246
- #
247
- # children with role
248
- #
249
-
250
- def test_child_role
251
- env, problems = instantiate(%Q(
252
- TestNode text: "some text" {
253
- TestNode text: "child"
254
- childs:
255
- TestNode text: "child2"
256
- }
257
- ), TestMM)
258
- assert_no_problems(problems)
259
- assert_model_simple(env)
260
- end
261
-
262
- def test_child_role2
263
- env, problems = instantiate(%Q(
264
- TestNode text: "some text" {
265
- childs: [
266
- TestNode text: "child"
267
- TestNode text: "child2"
268
- ]
269
- }
270
- ), TestMM)
271
- assert_no_problems(problems)
272
- assert_model_simple(env)
273
- end
274
-
275
- def test_child_role3
276
- env, problems = instantiate(%Q(
277
- TestNode text: "some text" {
278
- childs:
279
- TestNode text: "child"
280
- childs:
281
- TestNode text: "child2"
282
- }
283
- ), TestMM)
284
- assert_no_problems(problems)
285
- assert_model_simple(env)
286
- end
287
-
288
- def test_child_role4
289
- env, problems = instantiate(%Q(
290
- TestNode text: "some text" {
291
- childs: [
292
- TestNode text: "child"
293
- ]
294
- childs: [
295
- TestNode text: "child2"
296
- ]
297
- }
298
- ), TestMM)
299
- assert_no_problems(problems)
300
- assert_model_simple(env)
301
- end
302
-
303
- def test_child_role_empty
304
- env, problems = instantiate(%Q(
305
- TestNode {
306
- childs: [
307
- ]
308
- }
309
- ), TestMM)
310
- assert_no_problems(problems)
311
- end
312
-
313
-
314
- #
315
- # whitespace
316
- #
317
-
318
- def test_whitespace1
319
- env, problems = instantiate(%Q(
320
- TestNode text: "some text" , nums: [ 1 , 2 ] {
321
-
322
- # comment
323
-
324
- TestNode text: "child"
325
-
326
- TestNode text: "child2"
327
-
328
- }
329
- ), TestMM)
330
- assert_no_problems(problems)
331
- assert_model_simple(env, :with_nums)
332
- end
333
-
334
- def test_whitespace2
335
- env, problems = instantiate(%Q(
336
- # comment1
337
-
338
- # comment2
339
-
340
- TestNode text: "some text" {
341
-
342
- childs:
343
-
344
- # comment
345
-
346
- TestNode text: "child"
347
-
348
- childs: [
349
-
350
- TestNode text: "child2"
351
-
352
- ]
353
-
354
- }
355
- ), TestMM)
356
- assert_no_problems(problems)
357
- assert_model_simple(env)
358
- end
359
-
360
- def test_no_newline_at_eof
361
- env, problems = instantiate(%Q(
362
- TestNode), TestMM)
363
- assert_no_problems(problems)
364
- end
365
-
366
- def test_no_newline_at_eof2
367
- env, problems = instantiate(%Q(
368
- TestNode {
369
- }), TestMM)
370
- assert_no_problems(problems)
371
- end
372
-
373
- #
374
- # references
375
- #
376
-
377
- def test_references
378
- unresolved_refs = []
379
- env, problems = instantiate(%Q(
380
- TestNode text: "root" {
381
- TestNode related: /
382
- TestNode related: //
383
- TestNode related: /some
384
- TestNode related: //some
385
- TestNode related: /some/
386
- TestNode related: some/
387
- TestNode related: some//
388
- TestNode related: some
389
- TestNode related: /some/reference
390
- TestNode related: /some/reference/
391
- TestNode related: some/reference/
392
- TestNode related: some/reference
393
- }
394
- ), TestMM, :unresolved_refs => unresolved_refs)
395
- assert_no_problems(problems)
396
- ref_targets = [
397
- "/",
398
- "//",
399
- "/some",
400
- "//some",
401
- "/some/",
402
- "some/",
403
- "some//",
404
- "some",
405
- "/some/reference",
406
- "/some/reference/",
407
- "some/reference/",
408
- "some/reference"
409
- ]
410
- assert_equal ref_targets, env.find(:text => "root").first.childs.collect{|c| c.related.targetIdentifier}
411
- assert_equal ref_targets, unresolved_refs.collect{|ur| ur.proxy.targetIdentifier}
412
- assert unresolved_refs.all?{|ur| ur.feature_name == "related"}
413
- end
414
-
415
- def test_references_many
416
- env, problems = instantiate(%Q(
417
- TestNode text: "root" {
418
- TestNode others: /other
419
- TestNode others: [ /other ]
420
- TestNode others: [ /other1, /other2 ]
421
- }
422
- ), TestMM)
423
- assert_no_problems(problems)
424
- assert_equal [
425
- [ "/other" ],
426
- [ "/other" ],
427
- [ "/other1", "/other2" ],
428
- ], env.find(:text => "root").first.childs.collect{|c| c.others.collect{|p| p.targetIdentifier}}
429
- end
430
-
431
- def test_reference_regexp
432
- env, problems = instantiate(%Q(
433
- TestNode text: "root" {
434
- TestNode related: some
435
- TestNode related: ::some
436
- TestNode related: some::reference
437
- TestNode related: ::some::reference
438
- }
439
- ), TestMM, :reference_regexp => /\A\w*(::\w*)+/)
440
- assert_no_problems(problems)
441
- assert_equal [
442
- "some",
443
- "::some",
444
- "some::reference",
445
- "::some::reference"
446
- ], env.find(:text => "root").first.childs.collect{|c| c.related.targetIdentifier}
447
- end
448
-
449
- #
450
- # unlabled arguments
451
- #
452
-
453
- def test_unlabled_arguments
454
- env, problems = instantiate(%Q(
455
- TestNode "some text", [1,2] {
456
- TestNode "child"
457
- TestNode "child2"
458
- }
459
- ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
460
- assert_no_problems(problems)
461
- assert_model_simple(env, :with_nums)
462
- end
463
-
464
- def test_unlabled_arguments_not_in_front
465
- env, problems = instantiate(%Q(
466
- TestNode nums: [1,2], "some text" {
467
- TestNode "child"
468
- TestNode "child2"
469
- }
470
- ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
471
- assert_no_problems(problems)
472
- assert_model_simple(env, :with_nums)
473
- end
474
-
475
- def test_unlabled_arguments_using_labled
476
- env, problems = instantiate(%Q(
477
- TestNode text: "some text", nums: [1,2] {
478
- TestNode text: "child"
479
- TestNode text: "child2"
480
- }
481
- ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
482
- assert_no_problems(problems)
483
- assert_model_simple(env, :with_nums)
484
- end
485
-
486
- def test_unlabled_arguments_subclass
487
- env, problems = instantiate(%Q(
488
- SubNode "some text", [1, 2] {
489
- TestNode text: "child"
490
- TestNode text: "child2"
491
- }
492
- ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
493
- assert_no_problems(problems)
494
- assert_model_simple(env, :with_nums)
495
- end
496
-
497
- #
498
- # context sensitive commands
499
- #
500
-
501
- def test_context_sensitive
502
- env, problems = instantiate(%Q(
503
- TestNode {
504
- Command {
505
- Command
506
- }
507
- }
508
- ), TestMMContextSensitiveCommands)
509
- assert_no_problems(problems)
510
- root = env.find(:class => TestMMContextSensitiveCommands::TestNode).first
511
- assert root != nil
512
- assert(root.command.is_a?(TestMMContextSensitiveCommands::SubPackage1::Command))
513
- assert(root.command.command.is_a?(TestMMContextSensitiveCommands::SubPackage2::Command))
514
- end
515
-
516
- def test_context_sensitive_command_name_mapping
517
- env, problems = instantiate(%Q(
518
- Command {
519
- Command {
520
- Command
521
- }
522
- }
523
- ), TestMMContextSensitiveCommands, :command_name_provider => lambda do |c|
524
- "Command" end)
525
- assert_no_problems(problems)
526
- root = env.find(:class => TestMMContextSensitiveCommands::TestNode).first
527
- assert root != nil
528
- assert(root.command.is_a?(TestMMContextSensitiveCommands::SubPackage1::Command))
529
- assert(root.command.command.is_a?(TestMMContextSensitiveCommands::SubPackage2::Command))
530
- end
531
-
532
- #
533
- # problems
534
- #
535
-
536
- def test_unexpected_end_of_file
537
- env, problems = instantiate(%Q(
538
- TestNode text: "some text" {
539
- ), TestMM)
540
- assert_problems([[/unexpected end of file, expected \}/i, 2]], problems)
541
- end
542
-
543
- def test_unknown_command
544
- env, problems = instantiate(%Q(
545
- NotDefined
546
- ), TestMM)
547
- assert_problems([[/unknown command 'NotDefined'/i, 2]], problems)
548
- end
549
-
550
- def test_unknown_command_abstract
551
- env, problems = instantiate(%Q(
552
- TestNode
553
- ), TestMMAbstract)
554
- assert_problems([[/unknown command 'TestNode'/i, 2]], problems)
555
- end
556
-
557
- def test_unexpected_unlabled_argument
558
- env, problems = instantiate(%Q(
559
- TestNode "more text"
560
- ), TestMM)
561
- assert_problems([[/unexpected unlabled argument, 0 unlabled arguments expected/i, 2]], problems)
562
- end
563
-
564
- def test_unknown_child_role
565
- env, problems = instantiate(%Q(
566
- TestNode {
567
- notdefined:
568
- TestNode
569
- }
570
- ), TestMM)
571
- assert_problems([[/unknown child role 'notdefined'/i, 3]], problems)
572
- end
573
-
574
- def test_not_a_child_role
575
- env, problems = instantiate(%Q(
576
- TestNode {
577
- text:
578
- TestNode
579
- others:
580
- TestNode
581
- }
582
- ), TestMM)
583
- assert_problems([
584
- [/role 'text' can not take child elements/i, 3],
585
- [/role 'others' can not take child elements/i, 5]
586
- ], problems)
587
- end
588
-
589
- def test_not_a_single_child
590
- env, problems = instantiate(%Q(
591
- TestNode {
592
- singleChild: [
593
- TestNode
594
- TestNode
595
- ]
596
- }
597
- ), TestMM2)
598
- assert_problems([
599
- [/only one child allowed in role 'singleChild'/i, 5]
600
- ], problems)
601
- end
602
-
603
- def test_not_a_single_child2
604
- env, problems = instantiate(%Q(
605
- TestNode {
606
- singleChild:
607
- TestNode
608
- singleChild: [
609
- ]
610
- singleChild:
611
- TestNode
612
- }
613
- ), TestMM2)
614
- assert_problems([
615
- [/only one child allowed in role 'singleChild'/i, 8]
616
- ], problems)
617
- end
618
-
619
- def test_wrong_child_role
620
- env, problems = instantiate(%Q(
621
- TestNode {
622
- singleChild:
623
- TestNode2
624
- }
625
- ), TestMM2)
626
- assert_problems([
627
- [/role 'singleChild' can not take a TestNode2, expected TestNode/i, 4]
628
- ], problems)
629
- end
630
-
631
- def test_child_role_without_child
632
- env, problems = instantiate(%Q(
633
- TestNode {
634
- singleChild:
635
- }
636
- ), TestMM2)
637
- assert_problems([
638
- [/unexpected \}, expected identifier/i, 4]
639
- ], problems)
640
- end
641
-
642
- def test_wrong_child
643
- env, problems = instantiate(%Q(
644
- TestNode {
645
- TestNode3
646
- }
647
- ), TestMM2)
648
- assert_problems([
649
- [/command 'TestNode3' can not be used in this context/i, 3]
650
- ], problems)
651
- end
652
-
653
- def test_ambiguous_child_role
654
- env, problems = instantiate(%Q(
655
- TestNode {
656
- TestNode2
657
- }
658
- ), TestMM2)
659
- assert_problems([
660
- [/role of element is ambiguous, use a role label/i, 3]
661
- ], problems)
662
- end
663
-
664
- def test_non_ambiguous_child_role_subclass
665
- env, problems = instantiate(%Q(
666
- TestNode {
667
- TestNode4
668
- }
669
- ), TestMM2)
670
- assert_no_problems(problems)
671
- end
672
-
673
- def test_not_a_single_child3
674
- env, problems = instantiate(%Q(
675
- TestNode {
676
- TestNode
677
- TestNode
678
- }
679
- ), TestMM2)
680
- assert_problems([
681
- [/only one child allowed in role 'singleChild'/i, 4]
682
- ], problems)
683
- end
684
-
685
- def test_unknown_argument
686
- env, problems = instantiate(%Q(
687
- TestNode unknown: "some text"
688
- ), TestMM)
689
- assert_problems([[/unknown argument 'unknown'/i, 2]], problems)
690
- end
691
-
692
- def test_attribute_in_child_reference
693
- env, problems = instantiate(%Q(
694
- TestNode singleChild: "some text"
695
- ), TestMM2)
696
- assert_problems([[/argument 'singleChild' can only take child elements/i, 2]], problems)
697
- end
698
-
699
- def test_arguments_duplicate
700
- env, problems = instantiate(%Q(
701
- TestNode text: "some text", text: "more text"
702
- ), TestMM)
703
- assert_problems([[/argument 'text' already defined/i, 2]], problems)
704
- end
705
-
706
- def test_unlabled_arguments_duplicate
707
- env, problems = instantiate(%Q(
708
- TestNode text: "some text", "more text"
709
- ), TestMM, :unlabled_arguments => proc {|c| ["text"]})
710
- assert_problems([[/argument 'text' already defined/i, 2]], problems)
711
- end
712
-
713
- def test_multiple_arguments_in_non_many_attribute
714
- env, problems = instantiate(%Q(
715
- TestNode text: ["text1", "text2"]
716
- ), TestMM)
717
- assert_problems([[/argument 'text' can take only one value/i, 2]], problems)
718
- end
719
-
720
- def test_wrong_argument_type
721
- env, problems = instantiate(%Q(
722
- TestNode text: 1
723
- TestNode integer: "text"
724
- TestNode integer: true
725
- TestNode integer: 1.2
726
- TestNode integer: a
727
- TestNode integer: /a
728
- TestNode enum: 1
729
- TestNode enum: x
730
- TestNode related: 1
731
- ), TestMM)
732
- assert_problems([
733
- [/argument 'text' can not take a integer, expected string/i, 2],
734
- [/argument 'integer' can not take a string, expected integer/i, 3],
735
- [/argument 'integer' can not take a boolean, expected integer/i, 4],
736
- [/argument 'integer' can not take a float, expected integer/i, 5],
737
- [/argument 'integer' can not take a identifier, expected integer/i, 6],
738
- [/argument 'integer' can not take a reference, expected integer/i, 7],
739
- [/argument 'enum' can not take a integer, expected identifier/i, 8],
740
- [/argument 'enum' can not take value x, expected A, B/i, 9],
741
- [/argument 'related' can not take a integer, expected reference, identifier/i, 10]
742
- ], problems)
743
- end
744
-
745
- def test_missing_opening_brace
746
- env, problems = instantiate(%Q(
747
- TestNode
748
- }
749
- ), TestMM)
750
- assert_problems([[/unexpected \}, expected identifier/i, 3]], problems)
751
- end
752
-
753
- def test_invalid_root
754
- env, problems = instantiate(%Q(
755
- NonRootClass
756
- ), TestMMNonRootClass)
757
- assert_problems([[/command 'NonRootClass' can not be used on root level/i, 2]], problems)
758
- end
759
-
760
- def test_invalid_root_label
761
- root_elements = []
762
- env, problems = instantiate(%Q(
763
- TestNode text : A
764
- ), TestMM, :root_elements => root_elements)
765
- assert_problems([
766
- [/Unexpected unlabled argument, 0 unlabled arguments expected/i, 2],
767
- [/Unexpected :, expected newline/i, 2]
768
- ], problems)
769
- end
770
-
771
- #
772
- # problem recovery
773
- #
774
-
775
- def test_missing_value
776
- root_elements = []
777
- env, problems = instantiate(%Q(
778
- TestNode nums: 1, text:
779
- TestNode nums: 2, text: {
780
- SubNode
781
- }
782
- TestNode text: ,nums: 3 {
783
- SubNode
784
- }
785
- TestNode nums: , text: , bla:
786
- ), TestMM, :root_elements => root_elements)
787
- assert_equal 4, root_elements.size
788
- assert_equal [1], root_elements[0].nums
789
- assert_nil root_elements[0].text
790
- assert_equal [2], root_elements[1].nums
791
- assert_equal 1, root_elements[1].childs.size
792
- assert_equal [3], root_elements[2].nums
793
- assert_equal 1, root_elements[2].childs.size
794
- assert_problems([
795
- [/unexpected newline, expected.*integer/i, 2],
796
- [/unexpected \{, expected.*integer/i, 3],
797
- [/unexpected ,, expected.*integer/i, 6],
798
- [/unexpected ,, expected.*integer/i, 9],
799
- [/unexpected ,, expected.*integer/i, 9],
800
- [/unexpected newline, expected.*integer/i, 9],
801
- [/unknown argument 'bla'/i, 9],
802
- ], problems)
803
- end
804
-
805
- def test_missing_comma
806
- root_elements = []
807
- env, problems = instantiate(%Q(
808
- TestNode nums: 1 text: "bla"
809
- ), TestMM, :root_elements => root_elements)
810
- assert_equal 1, root_elements.size
811
- assert_equal [1], root_elements[0].nums
812
- assert_equal "bla", root_elements[0].text
813
- assert_problems([
814
- [/unexpected label .*, expected ,/i, 2],
815
- ], problems)
816
- end
817
-
818
- def test_missing_label
819
- root_elements = []
820
- env, problems = instantiate(%Q(
821
- TestNode nums: 1 "bla"
822
- ), TestMM, :root_elements => root_elements)
823
- assert_equal 1, root_elements.size
824
- assert_equal [1], root_elements[0].nums
825
- assert_problems([
826
- [/unexpected string 'bla', expected ,/i, 2],
827
- [/unexpected unlabled argument/i, 2]
828
- ], problems)
829
- end
830
-
831
- def test_unclosed_bracket1
832
- root_elements = []
833
- env, problems = instantiate(%Q(
834
- TestNode nums: [1, "bla"
835
- ), TestMM, :root_elements => root_elements)
836
- assert_equal 1, root_elements.size
837
- assert_equal [1], root_elements[0].nums
838
- assert_nil root_elements[0].text
839
- assert_problems([
840
- [/unexpected newline, expected \]/i, 2],
841
- [/argument 'nums' can not take a string, expected integer/i, 2],
842
- ], problems)
843
- end
844
-
845
- def test_unclosed_bracket2
846
- root_elements = []
847
- env, problems = instantiate(%Q(
848
- TestNode nums: [1, text: "bla"
849
- ), TestMM, :root_elements => root_elements)
850
- assert_equal 1, root_elements.size
851
- assert_equal [1], root_elements[0].nums
852
- assert_equal "bla", root_elements[0].text
853
- assert_problems([
854
- [/unexpected label 'text', expected identifier/i, 2],
855
- ], problems)
856
- end
857
-
858
- def test_unclosed_bracket3
859
- root_elements = []
860
- env, problems = instantiate(%Q(
861
- TestNode nums: [1 text: "bla"
862
- ), TestMM, :root_elements => root_elements)
863
- assert_equal 1, root_elements.size
864
- assert_equal [1], root_elements[0].nums
865
- assert_equal "bla", root_elements[0].text
866
- assert_problems([
867
- [/unexpected label 'text', expected \]/i, 2],
868
- ], problems)
869
- end
870
-
871
- def test_unclosed_bracket4
872
- root_elements = []
873
- env, problems = instantiate(%Q(
874
- TestNode nums: [1 "bla"
875
- ), TestMM, :root_elements => root_elements)
876
- assert_equal 1, root_elements.size
877
- assert_equal [1], root_elements[0].nums
878
- assert_nil root_elements[0].text
879
- assert_problems([
880
- [/unexpected string 'bla', expected ,/i, 2],
881
- [/argument 'nums' can not take a string, expected integer/i, 2],
882
- [/unexpected newline, expected \]/i, 2],
883
- ], problems)
884
- end
885
-
886
- def test_unclosed_bracket5
887
- root_elements = []
888
- env, problems = instantiate(%Q(
889
- TestNode [1, "bla"
890
- ), TestMM, :root_elements => root_elements)
891
- assert_equal 1, root_elements.size
892
- assert_equal [], root_elements[0].nums
893
- assert_nil root_elements[0].text
894
- assert_problems([
895
- [/unexpected newline, expected \]/i, 2],
896
- [/unexpected unlabled argument/i, 2],
897
- ], problems)
898
- end
899
-
900
- def test_unclosed_bracket6
901
- root_elements = []
902
- env, problems = instantiate(%Q(
903
- TestNode [1, "bla" [
904
- ), TestMM, :root_elements => root_elements)
905
- assert_equal 1, root_elements.size
906
- assert_problems([
907
- [/unexpected \[, expected \]/i, 2],
908
- [/unexpected end of file, expected \]/i, 2],
909
- [/unexpected unlabled argument/i, 2],
910
- [/unexpected unlabled argument/i, 2],
911
- ], problems)
912
- end
913
-
914
- def test_unclosed_bracket7
915
- root_elements = []
916
- env, problems = instantiate(%Q(
917
- TestNode [1, "bla", [
918
- ), TestMM, :root_elements => root_elements)
919
- assert_equal 1, root_elements.size
920
- assert_problems([
921
- [/unexpected \[, expected identifier/i, 2],
922
- [/unexpected unlabled argument/i, 2],
923
- [/unexpected unlabled argument/i, 2],
924
- [/unexpected end of file, expected \]/i, 2],
925
- ], problems)
926
- end
927
-
928
- def test_closing_bracket
929
- root_elements = []
930
- env, problems = instantiate(%Q(
931
- TestNode ]
932
- TestNode 1 ]
933
- TestNode 1, ]
934
- TestNode nums: ]1, "bla"
935
- TestNode text: "bla" ]
936
- ), TestMM, :root_elements => root_elements)
937
- assert_equal 5, root_elements.size
938
- assert_equal [], root_elements[3].nums
939
- assert_equal "bla", root_elements[4].text
940
- assert_problems([
941
- [/unexpected \], expected newline/i, 2],
942
- [/unexpected \], expected newline/i, 3],
943
- [/unexpected unlabled argument/i, 3],
944
- [/unexpected \], expected identifier/i, 4],
945
- [/unexpected unlabled argument/i, 4],
946
- [/unexpected \], expected identifier/i, 5],
947
- [/unexpected \], expected newline/i, 6],
948
- ], problems)
949
- end
950
-
951
- def test_closing_brace
952
- root_elements = []
953
- env, problems = instantiate(%Q(
954
- TestNode }
955
- TestNode 1 }
956
- TestNode 1, }
957
- TestNode nums: }1, "bla"
958
- TestNode text: "bla" }
959
- ), TestMM, :root_elements => root_elements)
960
- assert_equal 5, root_elements.size
961
- assert_equal [], root_elements[3].nums
962
- assert_equal "bla", root_elements[4].text
963
- assert_problems([
964
- [/unexpected \}, expected newline/i, 2],
965
- [/unexpected \}, expected newline/i, 3],
966
- [/unexpected unlabled argument/i, 3],
967
- [/unexpected \}, expected identifier/i, 4],
968
- [/unexpected unlabled argument/i, 4],
969
- [/unexpected \}, expected identifier/i, 5],
970
- [/unexpected \}, expected newline/i, 6],
971
- ], problems)
972
- end
973
-
974
- def test_starting_non_command
975
- root_elements = []
976
- env, problems = instantiate(%Q(
977
- \)
978
- TestNode
979
- *
980
- TestNode
981
- $
982
- TestNode
983
- ,
984
- TestNode
985
- [
986
- TestNode
987
- {
988
- TestNode
989
- ]
990
- TestNode
991
- }
992
- TestNode
993
- }}
994
- ), TestMM, :root_elements => root_elements)
995
- assert_equal 8, root_elements.size
996
- assert_problems([
997
- [/parse error on token '\)'/i, 2],
998
- [/parse error on token '\*'/i, 4],
999
- [/parse error on token '\$'/i, 6],
1000
- [/unexpected ,, expected identifier/i, 8],
1001
- [/unexpected \[, expected identifier/i, 10],
1002
- [/unexpected \{, expected identifier/i, 12],
1003
- [/unexpected \], expected identifier/i, 14],
1004
- [/unexpected \}, expected identifier/i, 16],
1005
- [/unexpected \}, expected identifier/i, 18],
1006
- ], problems)
1007
- end
1008
-
1009
- def test_parse_error_in_argument_list
1010
- root_elements = []
1011
- env, problems = instantiate(%Q(
1012
- TestNode text: "bla", * nums: 1
1013
- TestNode text: "bla" * , nums: 1
1014
- TestNode ?text: "bla"
1015
- TestNode nums: [1, * 3]
1016
- ), TestMM, :root_elements => root_elements)
1017
- assert_equal 4, root_elements.size
1018
- assert_equal "bla", root_elements[0].text
1019
- assert_equal [1], root_elements[0].nums
1020
- assert_equal "bla", root_elements[1].text
1021
- assert_equal [1], root_elements[1].nums
1022
- assert_equal "bla", root_elements[2].text
1023
- assert_equal [1, 3], root_elements[3].nums
1024
- assert_problems([
1025
- [/parse error on token '\*'/i, 2],
1026
- [/parse error on token '\*'/i, 3],
1027
- [/parse error on token '\?'/i, 4],
1028
- [/parse error on token '\*'/i, 5],
1029
- ], problems)
1030
- end
1031
-
1032
- def test_unclosed_brace
1033
- root_elements = []
1034
- env, problems = instantiate(%Q(
1035
- TestNode {
1036
- ), TestMM, :root_elements => root_elements)
1037
- assert_equal 1, root_elements.size
1038
- assert_problems([
1039
- [/unexpected end of file, expected \}/i, 2]
1040
- ], problems)
1041
- end
1042
-
1043
- def test_unclosed_brace2
1044
- root_elements = []
1045
- env, problems = instantiate(%Q(
1046
- TestNode {
1047
- *
1048
- ), TestMM, :root_elements => root_elements)
1049
- assert_equal 1, root_elements.size
1050
- assert_problems([
1051
- [/parse error on token '\*'/i, 3]
1052
- ], problems)
1053
- end
1054
-
1055
- def test_unclosed_brace3
1056
- root_elements = []
1057
- env, problems = instantiate(%Q(
1058
- TestNode {
1059
- childs:
1060
- ), TestMM, :root_elements => root_elements)
1061
- assert_equal 1, root_elements.size
1062
- assert_problems([
1063
- [/unexpected end of file, expected identifier/i, 3]
1064
- ], problems)
1065
- end
1066
-
1067
- def test_label_without_child
1068
- root_elements = []
1069
- env, problems = instantiate(%Q(
1070
- TestNode {
1071
- childs:
1072
- }
1073
- ), TestMM, :root_elements => root_elements)
1074
- assert_equal 1, root_elements.size
1075
- assert_problems([
1076
- [/unexpected \}, expected identifier/i, 4]
1077
- ], problems)
1078
- end
1079
-
1080
- def test_unclosed_child_bracket
1081
- root_elements = []
1082
- env, problems = instantiate(%Q(
1083
- TestNode {
1084
- childs: [
1085
- ), TestMM, :root_elements => root_elements)
1086
- assert_equal 1, root_elements.size
1087
- assert_problems([
1088
- [/unexpected end of file, expected \]/i, 3]
1089
- ], problems)
1090
- end
1091
-
1092
- def test_child_label_problems
1093
- root_elements = []
1094
- env, problems = instantiate(%Q(
1095
- TestNode {
1096
- childs: x
1097
- SubNode
1098
- childs: *
1099
- SubNode
1100
- childs: &
1101
- }
1102
- ), TestMM, :root_elements => root_elements)
1103
- assert_equal 1, root_elements.size
1104
- assert_equal 2, root_elements[0].childs.size
1105
- assert_problems([
1106
- [/unexpected identifier 'x', expected newline/i, 3],
1107
- [/parse error on token '\*'/i, 5],
1108
- [/parse error on token '&'/i, 7]
1109
- ], problems)
1110
- end
1111
-
1112
- def test_child_label_problems_with_bracket
1113
- root_elements = []
1114
- env, problems = instantiate(%Q(
1115
- TestNode {
1116
- childs: [ x
1117
- SubNode
1118
- ]
1119
- childs: [ *
1120
- SubNode
1121
- ]
1122
- childs: [&
1123
- ]
1124
- }
1125
- ), TestMM, :root_elements => root_elements)
1126
- assert_equal 1, root_elements.size
1127
- assert_equal 2, root_elements[0].childs.size
1128
- assert_problems([
1129
- [/unexpected identifier 'x', expected newline/i, 3],
1130
- [/parse error on token '\*'/i, 6],
1131
- [/parse error on token '&'/i, 9]
1132
- ], problems)
1133
- end
1134
-
1135
- def test_missing_closing_bracket
1136
- root_elements = []
1137
- env, problems = instantiate(%Q(
1138
- TestNode {
1139
- childs: [
1140
- SubNode
1141
- childs: [
1142
- SubNode
1143
- SubNode
1144
- }
1145
- ), TestMM, :root_elements => root_elements)
1146
- assert_equal 1, root_elements.size
1147
- assert_equal 3, root_elements[0].childs.size
1148
- assert_problems([
1149
- [/unexpected label 'childs', expected identifier/i, 5],
1150
- [/unexpected \}, expected identifier/i, 8],
1151
- ], problems)
1152
- end
1153
-
1154
- def test_missing_closing_brace
1155
- root_elements = []
1156
- env, problems = instantiate(%Q(
1157
- TestNode {
1158
- TestNode {
1159
- TestNode
1160
- }
1161
- ), TestMM, :root_elements => root_elements)
1162
- assert_equal 1, root_elements.size
1163
- assert_equal 1, root_elements[0].childs.size
1164
- assert_equal 1, root_elements[0].childs[0].childs.size
1165
- assert_problems([
1166
- [/unexpected end of file, expected \}/i, 5],
1167
- ], problems)
1168
- end
1169
-
1170
- #
1171
- # command name provider
1172
- #
1173
-
1174
- def test_command_name_provider
1175
- env, problems = instantiate(%Q(
1176
- TestNodeX text: "some text", nums: [1,2] {
1177
- TestNodeX text: "child"
1178
- TestNodeX text: "child2"
1179
- }
1180
- ), TestMM, :command_name_provider => proc do |c|
1181
- c.name + "X"
1182
- end)
1183
- assert_no_problems(problems)
1184
- assert_model_simple(env, :with_nums)
1185
- end
1186
-
1187
- def test_command_name_provider_ambiguous
1188
- begin
1189
- env, problems = instantiate(%Q(
1190
- TestNode
1191
- ), TestMM, :command_name_provider => proc do |c|
1192
- "Fixed"
1193
- end)
1194
- assert false
1195
- rescue RuntimeError => e
1196
- assert e.message =~ /ambiguous command name/
1197
- end
1198
- end
1199
-
1200
- #
1201
- # comment handler
1202
- #
1203
-
1204
- def test_comment_handler
1205
- proc_calls = 0
1206
- env, problems = instantiate(%Q(
1207
- #comment
1208
- TestNode text: "node1"
1209
- #comment
1210
- # multiline
1211
- TestNode text: "node2"
1212
- TestNode text: "node3" #comment
1213
- #above
1214
- TestNode text: "node4" {#right1
1215
- childs: [ #right2
1216
- #unassociated1
1217
- ] #right3
1218
- #unassociated2
1219
- } #below
1220
- #above1
1221
- #above2
1222
- TestNode text: "node5" { #right1
1223
- childs: #right2
1224
- TestNode
1225
- }#below
1226
- #comment without
1227
- #an element following
1228
- ), TestMM, :comment_handler => proc {|c,k,e,env|
1229
- proc_calls += 1
1230
- if e.nil?
1231
- case proc_calls
1232
- when 4
1233
- assert_equal "unassociated1", c
1234
- assert_equal :unassociated, k
1235
- when 5
1236
- assert_equal "unassociated2", c
1237
- assert_equal :unassociated, k
1238
- when 15
1239
- assert_equal "comment without\nan element following", c
1240
- assert_equal :unassociated, k
1241
- end
1242
- elsif e.text == "node1"
1243
- assert_equal "comment", c
1244
- assert_equal :above, k
1245
- elsif e.text == "node2"
1246
- assert_equal "comment\n multiline", c
1247
- assert_equal :above, k
1248
- elsif e.text == "node3"
1249
- assert_equal "comment", c
1250
- assert_equal :eol, k
1251
- elsif e.text == "node4"
1252
- case proc_calls
1253
- when 6
1254
- assert_equal "above", c
1255
- assert_equal :above, k
1256
- when 7
1257
- assert_equal "right1", c
1258
- assert_equal :eol, k
1259
- when 8
1260
- assert_equal "right2", c
1261
- assert_equal :eol, k
1262
- when 9
1263
- assert_equal "right3", c
1264
- assert_equal :eol, k
1265
- when 10
1266
- assert_equal "below", c
1267
- assert_equal :eol, k
1268
- end
1269
- elsif e.text == "node5"
1270
- case proc_calls
1271
- when 11
1272
- assert_equal "above1\nabove2", c
1273
- assert_equal :above, k
1274
- when 12
1275
- assert_equal "right1", c
1276
- assert_equal :eol, k
1277
- when 13
1278
- assert_equal "right2", c
1279
- assert_equal :eol, k
1280
- when 14
1281
- assert_equal "below", c
1282
- assert_equal :eol, k
1283
- end
1284
- else
1285
- assert false, "unexpected element in comment handler"
1286
- end
1287
- true
1288
- })
1289
- assert_no_problems(problems)
1290
- assert_equal 15, proc_calls
1291
- end
1292
-
1293
- def test_comment_handler_comment_not_allowed
1294
- env, problems = instantiate(%Q(
1295
- #comment
1296
- TestNode
1297
- ), TestMM, :comment_handler => proc {|c,k,e,env|
1298
- false
1299
- })
1300
- assert_problems([[/element can not take this comment/, 3]], problems)
1301
- end
1302
-
1303
- def test_comment_handler_comment_not_allowed_unassociated
1304
- env, problems = instantiate(%Q(
1305
- #comment
1306
- ), TestMM, :comment_handler => proc {|c,k,e,env|
1307
- false
1308
- })
1309
- assert_problems([[/Unassociated comment not allowed/, 2]], problems)
1310
- end
1311
-
1312
- #
1313
- # annotations
1314
- #
1315
-
1316
- def test_annotation_not_supported
1317
- env, problems = instantiate(%Q(
1318
- @annotation
1319
- TestNode
1320
- ), TestMM)
1321
- assert_problems([[/annotation not allowed/i, 3]], problems)
1322
- end
1323
-
1324
- def test_annotation_not_allowed
1325
- env, problems = instantiate(%Q(
1326
- @annotation
1327
- TestNode
1328
- ), TestMM, :annotation_handler => proc {|a,e,env|
1329
- false
1330
- })
1331
- assert_problems([[/annotation not allowed/i, 3]], problems)
1332
- end
1333
-
1334
- def test_annotation_in_wrong_places
1335
- env, problems = instantiate(%Q(
1336
- @annotation
1337
- #comment
1338
- TestNode {
1339
- @annotation
1340
- childs:
1341
- TestNode
1342
- @annotation
1343
- }
1344
- @annotation
1345
- ), TestMM)
1346
- assert_problems([
1347
- [/unexpected comment 'comment', expected identifier/i, 3],
1348
- [/unexpected label 'childs', expected identifier/i, 6],
1349
- [/unexpected \}, expected identifier/i, 9],
1350
- [/unexpected end of file, expected identifier/i, 10]
1351
- ], problems)
1352
- end
1353
-
1354
- def test_annotation_handler
1355
- annotations = []
1356
- elements = []
1357
- env, problems = instantiate(%Q(
1358
- @annotation
1359
- TestNode text: "aa"
1360
- @annotation
1361
- @ in a new line
1362
-
1363
- @ even with space in between
1364
-
1365
- TestNode text: "bb" {
1366
- @at child
1367
- TestNode text: "cc"
1368
- childs:
1369
- @after label
1370
- TestNode text: "dd"
1371
- @another child
1372
- TestNode text: "ee"
1373
- childs: [
1374
- @in brackets
1375
- TestNode text: "ff"
1376
- ]
1377
- }
1378
- ), TestMM, :annotation_handler => proc {|a,e,env|
1379
- annotations << a
1380
- elements << e
1381
- true
1382
- })
1383
- assert_equal "aa", elements[0].text
1384
- assert_equal "annotation", annotations[0]
1385
- assert_equal "cc", elements[1].text
1386
- assert_equal "at child", annotations[1]
1387
- assert_equal "dd", elements[2].text
1388
- assert_equal "after label", annotations[2]
1389
- assert_equal "ee", elements[3].text
1390
- assert_equal "another child", annotations[3]
1391
- assert_equal "ff", elements[4].text
1392
- assert_equal "in brackets", annotations[4]
1393
- assert_equal "bb", elements[5].text
1394
- assert_equal "annotation\n in a new line\n even with space in between", annotations[5]
1395
- assert_no_problems(problems)
1396
- end
1397
-
1398
- #
1399
- # generics
1400
- #
1401
-
1402
- def test_generics_parse_error
1403
- env, problems = instantiate(%Q(
1404
- TestNode text: <bla
1405
- TestNode text: bla>
1406
- TestNode text: <a<b>
1407
- TestNode text: <a>b>
1408
- TestNode text: <%a
1409
- TestNode text: <%a%
1410
- TestNode text: <%a%>b%>
1411
- ), TestMM, :enable_generics => true)
1412
- assert_problems([
1413
- [/parse error on token '<'/i, 2],
1414
- [/unexpected unlabled argument/i, 2],
1415
- [/parse error on token '>'/i, 3],
1416
- [/unexpected identifier 'b'/i, 5],
1417
- [/parse error on token '>'/i, 5],
1418
- [/unexpected unlabled argument/i, 5],
1419
- [/parse error on token '<'/i, 6],
1420
- [/unexpected unlabled argument/i, 6],
1421
- [/parse error on token '<'/i, 7],
1422
- [/unexpected unlabled argument/i, 7],
1423
- [/parse error on token '%'/i, 7],
1424
- [/unexpected identifier 'b'/i, 8],
1425
- [/unexpected unlabled argument/i, 8],
1426
- [/parse error on token '%'/i, 8],
1427
- ], problems)
1428
- end
1429
-
1430
- def test_generics
1431
- root_elements = []
1432
- env, problems = instantiate(%q(
1433
- TestNode text: <bla>, nums: [<1>, <%2%>], boolean: <truthy>, enum: <%option%>, float: <precise>, related: <%noderef%>, others: [<other1>, <%other2%>]
1434
- ), TestMM, :root_elements => root_elements, :enable_generics => true)
1435
- assert_no_problems(problems)
1436
- assert root_elements[0].text.is_a?(RText::Generic)
1437
- assert_equal "bla", root_elements[0].text.string
1438
- assert_equal ["1", "2"], root_elements[0].nums.collect{|n| n.string}
1439
- assert_equal "truthy", root_elements[0].boolean.string
1440
- assert_equal "option", root_elements[0].enum.string
1441
- assert_equal "precise", root_elements[0].float.string
1442
- assert_equal "noderef", root_elements[0].related.string
1443
- assert_equal ["other1", "other2"], root_elements[0].others.collect{|n| n.string}
1444
- end
1445
-
1446
- def test_generics_forbidden
1447
- env, problems = instantiate(%Q(\
1448
- TestNode text: <bla>
1449
- ), TestMM)
1450
- assert_problems([
1451
- [/generic value not allowed/i, 1],
1452
- ], problems)
1453
- end
1454
-
1455
- #
1456
- # subpackages
1457
- #
1458
-
1459
- def test_subpackage
1460
- env, problems = instantiate(%q(
1461
- TestNodeSub text: "something"
1462
- ), TestMMSubpackage)
1463
- assert_no_problems(problems)
1464
- assert_equal "something", env.elements.first.text
1465
- end
1466
-
1467
- #
1468
- # values
1469
- #
1470
-
1471
- def test_escapes
1472
- env, problems = instantiate(%q(
1473
- TestNode text: "some \" \\\\ \\\\\" text \r xx \n xx \r\n xx \t xx \b xx \f"
1474
- ), TestMM)
1475
- assert_no_problems(problems)
1476
- assert_equal %Q(some " \\ \\" text \r xx \n xx \r\n xx \t xx \b xx \f), env.elements.first.text
1477
- end
1478
-
1479
- def test_escape_single_backslash
1480
- env, problems = instantiate(%q(
1481
- TestNode text: "a single \\ will be just itself"
1482
- ), TestMM)
1483
- assert_no_problems(problems)
1484
- assert_equal %q(a single \\ will be just itself), env.elements.first.text
1485
- end
1486
-
1487
- def test_string_umlauts
1488
- env, problems = instantiate(%q(
1489
- TestNode text: "ä, ö, ü"
1490
- ), TestMM)
1491
- assert_no_problems(problems)
1492
- assert_equal %q(ä, ö, ü), env.elements.first.text
1493
- end
1494
-
1495
- def test_integer
1496
- env, problems = instantiate(%q(
1497
- TestNode integer: 7
1498
- TestNode integer: 4294967296
1499
- TestNode integer: 12345678901234567890
1500
- ), TestMM)
1501
- assert_no_problems(problems)
1502
- assert_equal 7, env.elements[0].integer
1503
- assert_equal 4294967296, env.elements[1].integer
1504
- assert_equal 12345678901234567890, env.elements[2].integer
1505
- end
1506
-
1507
- def test_integer_hex
1508
- env, problems = instantiate(%q(
1509
- TestNode text: root {
1510
- TestNode integer: 0x7
1511
- TestNode integer: 0X7
1512
- TestNode integer: 0x007
1513
- TestNode integer: 0x77
1514
- TestNode integer: 0xabCDEF
1515
- TestNode integer: 0xabcdefabcdefabcdef
1516
- }
1517
- ), TestMM)
1518
- assert_no_problems(problems)
1519
- assert_equal [7, 7, 7, 0x77, 0xABCDEF, 0xabcdefabcdefabcdef], env.find(:text => "root").first.childs.collect{|c| c.integer}
1520
- end
1521
-
1522
- def test_float
1523
- env, problems = instantiate(%q(
1524
- TestNode float: 1.23
1525
- TestNode float: 1.23e-08
1526
- TestNode float: 1.23e+10
1527
- TestNode float: 1234567890.123456789
1528
- ), TestMM)
1529
- assert_no_problems(problems)
1530
- assert_equal 1.23, env.elements[0].float
1531
- assert_equal 1.23e-08, env.elements[1].float
1532
- assert_equal 1.23e+10, env.elements[2].float
1533
- if rgen_with_bigdecimal?
1534
- assert env.elements[3].float.is_a?(BigDecimal)
1535
- assert_equal "1234567890.123456789", env.elements[3].float.to_s("F")
1536
- else
1537
- assert env.elements[3].float.is_a?(Float)
1538
- assert_equal "1234567890.1234567", env.elements[3].float.to_s
1539
- end
1540
- end
1541
-
1542
- def test_boolean
1543
- env, problems = instantiate(%q(
1544
- TestNode text: root {
1545
- TestNode boolean: true
1546
- TestNode boolean: false
1547
- }
1548
- ), TestMM)
1549
- assert_no_problems(problems)
1550
- assert_equal [true, false], env.find(:text => "root").first.childs.collect{|c| c.boolean}
1551
- end
1552
-
1553
- def test_enum
1554
- env, problems = instantiate(%q(
1555
- TestNode text: root {
1556
- TestNode enum: A
1557
- TestNode enum: B
1558
- TestNode enum: "non-word*chars"
1559
- TestNode enum: "2you"
1560
- }
1561
- ), TestMM)
1562
- assert_no_problems(problems)
1563
- assert_equal [:A, :B, :'non-word*chars', :'2you'], env.find(:text => "root").first.childs.collect{|c| c.enum}
1564
- end
1565
-
1566
- def test_with_bom
1567
- env, problems = instantiate(%Q(\xEF\xBB\xBF
1568
- TestNode text: "some text", nums: [1,2] {
1569
- TestNode text: "child"
1570
- TestNode text: "child2"
1571
- }
1572
- ), TestMM)
1573
- assert_no_problems(problems)
1574
- assert_model_simple(env, :with_nums)
1575
- end
1576
-
1577
- #
1578
- # conflicts with builtins
1579
- #
1580
-
1581
- def test_conflict_builtin
1582
- env, problems = instantiate(%q(
1583
- Data notTheBuiltin: "for sure"
1584
- ), TestMMData)
1585
- assert_no_problems(problems)
1586
- assert_equal "for sure", env.elements.first.notTheBuiltin
1587
- end
1588
-
1589
- def test_builtin_in_subpackage
1590
- env, problems = instantiate(%q(
1591
- Data notTheBuiltin: "for sure"
1592
- ), TestMMSubpackage)
1593
- assert_no_problems(problems)
1594
- assert_equal "for sure", env.elements.first.notTheBuiltin
1595
- end
1596
-
1597
- #
1598
- # encoding
1599
- #
1600
-
1601
- def test_encodings
1602
- input = %Q(TestNode text: "iso-8859-1 AE Umlaut: \xc4")
1603
- # force encoding to binary in order to prevent exceptions on invalid byte sequences
1604
- # if the encoding would be utf-8, there would be an exception with the string above
1605
- input.force_encoding("binary")
1606
- env, problems = instantiate(input, TestMM)
1607
- assert_no_problems(problems)
1608
- assert_match /AE Umlaut: /, env.elements.first.text
1609
- end
1610
-
1611
- #
1612
- # line breaks
1613
- #
1614
-
1615
- def test_linebreak
1616
- roots = []
1617
- env, problems = instantiate(%Q(
1618
- TestNode sometext,
1619
- integer: 1,
1620
- nums: [
1621
- 1,
1622
- 2
1623
- ]
1624
- ), TestMM, :root_elements => roots, :unlabled_arguments => proc {|clazz| ["text"]})
1625
- assert_no_problems(problems)
1626
- node = roots.first
1627
- assert_equal "sometext", node.text
1628
- assert_equal 1, node.integer
1629
- assert_equal [1,2], node.nums
1630
- end
1631
-
1632
- def test_linebreak_backslash
1633
- roots = []
1634
- env, problems = instantiate(%Q(
1635
- TestNode \\
1636
- sometext
1637
- ), TestMM, :root_elements => roots, :unlabled_arguments => proc {|clazz| ["text"]})
1638
- assert_no_problems(problems)
1639
- node = roots.first
1640
- assert_equal "sometext", node.text
1641
- end
1642
-
1643
- def test_linebreak_backslash_problems
1644
- roots = []
1645
- env, problems = instantiate(%Q(
1646
- TostNode \\
1647
- sometext
1648
- TostNode
1649
- ), TestMM, :root_elements => roots, :unlabled_arguments => proc {|clazz| ["text"]})
1650
- assert_problems([
1651
- [/unknown command/i, 2],
1652
- [/unknown command/i, 4],
1653
- ], problems)
1654
- end
1655
-
1656
- module TestMMObjectAttribute
1657
- extend RGen::MetamodelBuilder::ModuleExtension
1658
- class TestNode < RGen::MetamodelBuilder::MMBase
1659
- has_many_attr 'objs', Object
1660
- end
1661
- end
1662
-
1663
- def test_object_attribute
1664
- roots = []
1665
- env, problems = instantiate(%Q(
1666
- TestNode objs: ["some text", -123, someSymbol, true, false, -0.097]
1667
- ), TestMMObjectAttribute, :root_elements => roots)
1668
- assert_no_problems(problems)
1669
- node = roots.first
1670
- assert_equal ['some text', -123, 'someSymbol', true, false, -0.097], node.objs
1671
- end
1672
-
1673
- private
1674
-
1675
- def instantiate(text, mm, options={})
1676
- env = RGen::Environment.new
1677
- lang = RText::Language.new(mm.ecore, options.merge(
1678
- :root_classes => mm.ecore.eAllClasses.select{|c|
1679
- c.name == "TestNode" || c.name == "Data" || c.name == "TestNodeSub" || c.name == "SubNode"}))
1680
- inst = RText::Instantiator.new(lang)
1681
- problems = []
1682
- inst.instantiate(text, options.merge({:env => env, :problems => problems, :root_elements => options[:root_elements]}))
1683
- return env, problems
1684
- end
1685
-
1686
- def assert_no_problems(problems)
1687
- assert problems.empty?, problems.collect{|p| "#{p.message}, line: #{p.line}"}.join("\n")
1688
- end
1689
-
1690
- def assert_problems(expected, problems)
1691
- remaining = problems.dup
1692
- probs = []
1693
- expected.each do |e|
1694
- if e.is_a?(Array)
1695
- p = remaining.find{|p| p.message =~ e[0] && p.line == e[1]}
1696
- else
1697
- p = remaining.find{|p| p.message =~ e}
1698
- end
1699
- probs << "expected problem not present: #{e}" if !p
1700
- # make sure to not delete duplicate problems at once
1701
- idx = remaining.index(p)
1702
- remaining.delete_at(idx) if idx
1703
- end
1704
- remaining.each do |p|
1705
- probs << "unexpected problem: #{p.message}, line: #{p.line}"
1706
- end
1707
- assert probs.empty?, probs.join("\n")
1708
- end
1709
-
1710
- def assert_model_simple(env, *opts)
1711
- raise "unknown options" unless (opts - [:with_nums]).empty?
1712
- root = env.find(:class => TestMM::TestNode, :text => "some text").first
1713
- assert root != nil
1714
- assert_equal 2, root.childs.size
1715
- assert_equal [TestMM::TestNode, TestMM::TestNode], root.childs.collect{|c| c.class}
1716
- assert_equal ["child", "child2"], root.childs.text
1717
- if opts.include?(:with_nums)
1718
- assert_equal [1, 2], root.nums
1719
- end
1720
- end
1721
-
1722
- def rgen_with_bigdecimal?
1723
- begin
1724
- TestMM::TestNode.new.float = BigDecimal.new("0.0")
1725
- rescue StandardError
1726
- return false
1727
- end
1728
- true
1729
- end
1730
-
1731
- end
1732
-
1733
-
1
+ # coding: binary
2
+ $:.unshift File.join(File.dirname(__FILE__),"..","lib")
3
+
4
+ require 'minitest/autorun'
5
+ require 'bigdecimal'
6
+ require 'rgen/environment'
7
+ require 'rgen/metamodel_builder'
8
+ require 'rtext/instantiator'
9
+ require 'rtext/language'
10
+
11
+ class InstantiatorTest < MiniTest::Test
12
+
13
+ module TestMM
14
+ extend RGen::MetamodelBuilder::ModuleExtension
15
+ class TestNode < RGen::MetamodelBuilder::MMBase
16
+ SomeEnum = RGen::MetamodelBuilder::DataTypes::Enum.new([:A, :B, :'non-word*chars', :'2you'])
17
+ has_attr 'text', String
18
+ has_attr 'integer', Integer
19
+ has_attr 'boolean', Boolean
20
+ has_attr 'enum', SomeEnum
21
+ has_many_attr 'nums', Integer
22
+ has_attr 'float', Float
23
+ has_one 'related', TestNode
24
+ has_many 'others', TestNode
25
+ contains_many 'childs', TestNode, 'parent'
26
+ end
27
+ class SubNode < TestNode
28
+ end
29
+ end
30
+
31
+ module TestMM2
32
+ extend RGen::MetamodelBuilder::ModuleExtension
33
+ class TestNode < RGen::MetamodelBuilder::MMBase
34
+ contains_one 'singleChild', TestNode, 'parent'
35
+ end
36
+ class TestNode2 < RGen::MetamodelBuilder::MMBase
37
+ end
38
+ class TestNode3 < RGen::MetamodelBuilder::MMBase
39
+ end
40
+ class TestNode4 < TestNode
41
+ end
42
+ TestNode.contains_one 'singleChild2a', TestNode2, 'parentA'
43
+ TestNode.contains_one 'singleChild2b', TestNode2, 'parentB'
44
+ end
45
+
46
+ module TestMMLinenoFilenameFragment
47
+ extend RGen::MetamodelBuilder::ModuleExtension
48
+ class TestNode < RGen::MetamodelBuilder::MMBase
49
+ has_attr 'text', String
50
+ has_attr 'lineno', Integer
51
+ has_attr 'filename', String
52
+ has_attr 'fragmentr', String
53
+ contains_many 'childs', TestNode, 'parent'
54
+ end
55
+ end
56
+
57
+ module TestMMAbstract
58
+ extend RGen::MetamodelBuilder::ModuleExtension
59
+ class TestNode < RGen::MetamodelBuilder::MMBase
60
+ abstract
61
+ end
62
+ end
63
+
64
+ module TestMMData
65
+ extend RGen::MetamodelBuilder::ModuleExtension
66
+ # class "Data" exists in the standard Ruby namespace
67
+ class Data < RGen::MetamodelBuilder::MMBase
68
+ has_attr 'notTheBuiltin', String
69
+ end
70
+ end
71
+
72
+ module TestMMSubpackage
73
+ extend RGen::MetamodelBuilder::ModuleExtension
74
+ module SubPackage
75
+ extend RGen::MetamodelBuilder::ModuleExtension
76
+ class TestNodeSub < RGen::MetamodelBuilder::MMBase
77
+ has_attr 'text', String
78
+ end
79
+ class Data < RGen::MetamodelBuilder::MMBase
80
+ has_attr 'notTheBuiltin', String
81
+ end
82
+ end
83
+ end
84
+
85
+ module TestMMNonRootClass
86
+ extend RGen::MetamodelBuilder::ModuleExtension
87
+ class NonRootClass < RGen::MetamodelBuilder::MMBase
88
+ end
89
+ end
90
+
91
+ module TestMMContextSensitiveCommands
92
+ extend RGen::MetamodelBuilder::ModuleExtension
93
+ module SubPackage2
94
+ extend RGen::MetamodelBuilder::ModuleExtension
95
+ class Command < RGen::MetamodelBuilder::MMBase
96
+ end
97
+ end
98
+ module SubPackage1
99
+ extend RGen::MetamodelBuilder::ModuleExtension
100
+ class Command < RGen::MetamodelBuilder::MMBase
101
+ contains_one 'command', SubPackage2::Command, 'super'
102
+ end
103
+ end
104
+ class TestNode < RGen::MetamodelBuilder::MMBase
105
+ contains_one 'command', SubPackage1::Command, 'testNode'
106
+ end
107
+ end
108
+
109
+ def test_simple
110
+ env, problems = instantiate(%Q(
111
+ TestNode text: "some text", nums: [1,2] {
112
+ TestNode text: "child"
113
+ TestNode text: "child2"
114
+ }
115
+ ), TestMM)
116
+ assert_no_problems(problems)
117
+ assert_model_simple(env, :with_nums)
118
+ end
119
+
120
+ def test_multiple_roots
121
+ env, problems = instantiate(%Q(
122
+ TestNode
123
+ TestNode
124
+ ), TestMM)
125
+ assert_no_problems(problems)
126
+ assert_equal 2, env.elements.size
127
+ end
128
+
129
+ def test_comment
130
+ env, problems = instantiate(%Q(
131
+ # comment 1
132
+ TestNode text: "some text" {# comment 1.1
133
+ childs: [ # comment 1.2
134
+ # comment 2
135
+ TestNode text: "child" # comment 2.1
136
+ # comment 3
137
+ TestNode text: "child2" #comment 3.1
138
+ # unassociated
139
+ ] # comment 1.3
140
+ # unassociated
141
+ } # comment 1.4
142
+ #comment 1
143
+ TestNode { #comment 1.1
144
+ childs: # comment 1.2
145
+ TestNode text: "child" #comment2
146
+ # unassociated
147
+ }# comment 1.3
148
+ # unassociated
149
+ ), TestMM)
150
+ assert_no_problems(problems)
151
+ assert_model_simple(env)
152
+ end
153
+
154
+ def test_comment_only
155
+ env, problems = instantiate(%Q(
156
+ # comment 1
157
+ ), TestMM)
158
+ assert_no_problems(problems)
159
+ end
160
+
161
+ def test_empty
162
+ env, problems = instantiate("", TestMM)
163
+ assert_no_problems(problems)
164
+ end
165
+
166
+ #
167
+ # options
168
+ #
169
+
170
+ def test_line_number_setter
171
+ env, problems = instantiate(%q(
172
+ TestNode text: "node1" {
173
+ TestNode text: "node2"
174
+
175
+ #some comment
176
+ TestNode text: "node3"
177
+ }
178
+ TestNode text: "node4"
179
+ ), TestMMLinenoFilenameFragment, :line_number_attribute => "lineno")
180
+ assert_no_problems(problems)
181
+ assert_equal 2, env.find(:text => "node1").first.lineno
182
+ assert_equal 3, env.find(:text => "node2").first.lineno
183
+ assert_equal 6, env.find(:text => "node3").first.lineno
184
+ assert_equal 8, env.find(:text => "node4").first.lineno
185
+ end
186
+
187
+ def test_missing_line_number_setter
188
+ env, problems = instantiate(%Q(
189
+ TestNode text: A
190
+ ), TestMMLinenoFilenameFragment, :line_number_attribute => "wrong_attribute_name")
191
+ assert_no_problems(problems)
192
+ assert_nil env.elements.first.lineno
193
+ end
194
+
195
+ def test_root_elements
196
+ root_elements = []
197
+ env, problems = instantiate(%Q(
198
+ TestNode text: A
199
+ TestNode text: B
200
+ TestNode text: C
201
+ ), TestMM, :root_elements => root_elements)
202
+ assert_no_problems(problems)
203
+ assert_equal ["A", "B", "C"], root_elements.text
204
+ end
205
+
206
+ def test_file_name_option
207
+ env, problems = instantiate(%Q(
208
+ TestNode text: A
209
+ TestNode text: B
210
+ TestNode a problem here
211
+ ), TestMM, :file_name => "some_file")
212
+ assert_equal "some_file", problems.first.file
213
+ end
214
+
215
+ def test_file_name_setter
216
+ env, problems = instantiate(%Q(
217
+ TestNode text: A
218
+ ), TestMMLinenoFilenameFragment, :file_name => "some_file", :file_name_attribute => "filename")
219
+ assert_equal "some_file", env.elements.first.filename
220
+ end
221
+
222
+ def test_missing_file_name_setter
223
+ env, problems = instantiate(%Q(
224
+ TestNode text: A
225
+ ), TestMMLinenoFilenameFragment, :file_name => "some_file", :file_name_attribute => "wrong_attribute_name")
226
+ assert_nil env.elements.first.filename
227
+ end
228
+
229
+ def test_fragment_ref_setter
230
+ the_ref = "is a string here but would normally be an RGen fragment"
231
+ env, problems = instantiate(%Q(
232
+ TestNode text: A
233
+ ), TestMMLinenoFilenameFragment, :fragment_ref => the_ref, :fragment_ref_attribute => "fragmentr")
234
+ assert_equal the_ref.object_id, env.elements.first.fragmentr.object_id
235
+ end
236
+
237
+ def test_missing_fragment_ref_setter
238
+ the_ref = "is a string here but would normally be an RGen fragment"
239
+ env, problems = instantiate(%Q(
240
+ TestNode text: A
241
+ ), TestMMLinenoFilenameFragment, :fragment_ref => the_ref, :fragment_ref_attribute => "wrong_attribute_name")
242
+ assert_nil env.elements.first.fragmentr
243
+ end
244
+
245
+ #
246
+ # children with role
247
+ #
248
+
249
+ def test_child_role
250
+ env, problems = instantiate(%Q(
251
+ TestNode text: "some text" {
252
+ TestNode text: "child"
253
+ childs:
254
+ TestNode text: "child2"
255
+ }
256
+ ), TestMM)
257
+ assert_no_problems(problems)
258
+ assert_model_simple(env)
259
+ end
260
+
261
+ def test_child_role2
262
+ env, problems = instantiate(%Q(
263
+ TestNode text: "some text" {
264
+ childs: [
265
+ TestNode text: "child"
266
+ TestNode text: "child2"
267
+ ]
268
+ }
269
+ ), TestMM)
270
+ assert_no_problems(problems)
271
+ assert_model_simple(env)
272
+ end
273
+
274
+ def test_child_role3
275
+ env, problems = instantiate(%Q(
276
+ TestNode text: "some text" {
277
+ childs:
278
+ TestNode text: "child"
279
+ childs:
280
+ TestNode text: "child2"
281
+ }
282
+ ), TestMM)
283
+ assert_no_problems(problems)
284
+ assert_model_simple(env)
285
+ end
286
+
287
+ def test_child_role4
288
+ env, problems = instantiate(%Q(
289
+ TestNode text: "some text" {
290
+ childs: [
291
+ TestNode text: "child"
292
+ ]
293
+ childs: [
294
+ TestNode text: "child2"
295
+ ]
296
+ }
297
+ ), TestMM)
298
+ assert_no_problems(problems)
299
+ assert_model_simple(env)
300
+ end
301
+
302
+ def test_child_role_empty
303
+ env, problems = instantiate(%Q(
304
+ TestNode {
305
+ childs: [
306
+ ]
307
+ }
308
+ ), TestMM)
309
+ assert_no_problems(problems)
310
+ end
311
+
312
+
313
+ #
314
+ # whitespace
315
+ #
316
+
317
+ def test_whitespace1
318
+ env, problems = instantiate(%Q(
319
+ TestNode text: "some text" , nums: [ 1 , 2 ] {
320
+
321
+ # comment
322
+
323
+ TestNode text: "child"
324
+
325
+ TestNode text: "child2"
326
+
327
+ }
328
+ ), TestMM)
329
+ assert_no_problems(problems)
330
+ assert_model_simple(env, :with_nums)
331
+ end
332
+
333
+ def test_whitespace2
334
+ env, problems = instantiate(%Q(
335
+ # comment1
336
+
337
+ # comment2
338
+
339
+ TestNode text: "some text" {
340
+
341
+ childs:
342
+
343
+ # comment
344
+
345
+ TestNode text: "child"
346
+
347
+ childs: [
348
+
349
+ TestNode text: "child2"
350
+
351
+ ]
352
+
353
+ }
354
+ ), TestMM)
355
+ assert_no_problems(problems)
356
+ assert_model_simple(env)
357
+ end
358
+
359
+ def test_no_newline_at_eof
360
+ env, problems = instantiate(%Q(
361
+ TestNode), TestMM)
362
+ assert_no_problems(problems)
363
+ end
364
+
365
+ def test_no_newline_at_eof2
366
+ env, problems = instantiate(%Q(
367
+ TestNode {
368
+ }), TestMM)
369
+ assert_no_problems(problems)
370
+ end
371
+
372
+ #
373
+ # references
374
+ #
375
+
376
+ def test_references
377
+ unresolved_refs = []
378
+ env, problems = instantiate(%Q(
379
+ TestNode text: "root" {
380
+ TestNode related: /
381
+ TestNode related: //
382
+ TestNode related: /some
383
+ TestNode related: //some
384
+ TestNode related: /some/
385
+ TestNode related: some/
386
+ TestNode related: some//
387
+ TestNode related: some
388
+ TestNode related: /some/reference
389
+ TestNode related: /some/reference/
390
+ TestNode related: some/reference/
391
+ TestNode related: some/reference
392
+ }
393
+ ), TestMM, :unresolved_refs => unresolved_refs)
394
+ assert_no_problems(problems)
395
+ ref_targets = [
396
+ "/",
397
+ "//",
398
+ "/some",
399
+ "//some",
400
+ "/some/",
401
+ "some/",
402
+ "some//",
403
+ "some",
404
+ "/some/reference",
405
+ "/some/reference/",
406
+ "some/reference/",
407
+ "some/reference"
408
+ ]
409
+ assert_equal ref_targets, env.find(:text => "root").first.childs.collect{|c| c.related.targetIdentifier}
410
+ assert_equal ref_targets, unresolved_refs.collect{|ur| ur.proxy.targetIdentifier}
411
+ assert unresolved_refs.all?{|ur| ur.feature_name == "related"}
412
+ end
413
+
414
+ def test_references_many
415
+ env, problems = instantiate(%Q(
416
+ TestNode text: "root" {
417
+ TestNode others: /other
418
+ TestNode others: [ /other ]
419
+ TestNode others: [ /other1, /other2 ]
420
+ }
421
+ ), TestMM)
422
+ assert_no_problems(problems)
423
+ assert_equal [
424
+ [ "/other" ],
425
+ [ "/other" ],
426
+ [ "/other1", "/other2" ],
427
+ ], env.find(:text => "root").first.childs.collect{|c| c.others.collect{|p| p.targetIdentifier}}
428
+ end
429
+
430
+ def test_reference_regexp
431
+ env, problems = instantiate(%Q(
432
+ TestNode text: "root" {
433
+ TestNode related: some
434
+ TestNode related: ::some
435
+ TestNode related: some::reference
436
+ TestNode related: ::some::reference
437
+ }
438
+ ), TestMM, :reference_regexp => /\A\w*(::\w*)+/)
439
+ assert_no_problems(problems)
440
+ assert_equal [
441
+ "some",
442
+ "::some",
443
+ "some::reference",
444
+ "::some::reference"
445
+ ], env.find(:text => "root").first.childs.collect{|c| c.related.targetIdentifier}
446
+ end
447
+
448
+ #
449
+ # unlabled arguments
450
+ #
451
+
452
+ def test_unlabled_arguments
453
+ env, problems = instantiate(%Q(
454
+ TestNode "some text", [1,2] {
455
+ TestNode "child"
456
+ TestNode "child2"
457
+ }
458
+ ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
459
+ assert_no_problems(problems)
460
+ assert_model_simple(env, :with_nums)
461
+ end
462
+
463
+ def test_unlabled_arguments_not_in_front
464
+ env, problems = instantiate(%Q(
465
+ TestNode nums: [1,2], "some text" {
466
+ TestNode "child"
467
+ TestNode "child2"
468
+ }
469
+ ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
470
+ assert_no_problems(problems)
471
+ assert_model_simple(env, :with_nums)
472
+ end
473
+
474
+ def test_unlabled_arguments_using_labled
475
+ env, problems = instantiate(%Q(
476
+ TestNode text: "some text", nums: [1,2] {
477
+ TestNode text: "child"
478
+ TestNode text: "child2"
479
+ }
480
+ ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
481
+ assert_no_problems(problems)
482
+ assert_model_simple(env, :with_nums)
483
+ end
484
+
485
+ def test_unlabled_arguments_subclass
486
+ env, problems = instantiate(%Q(
487
+ SubNode "some text", [1, 2] {
488
+ TestNode text: "child"
489
+ TestNode text: "child2"
490
+ }
491
+ ), TestMM, :unlabled_arguments => proc {|clazz| ["text", "nums"]})
492
+ assert_no_problems(problems)
493
+ assert_model_simple(env, :with_nums)
494
+ end
495
+
496
+ #
497
+ # context sensitive commands
498
+ #
499
+
500
+ def test_context_sensitive
501
+ env, problems = instantiate(%Q(
502
+ TestNode {
503
+ Command {
504
+ Command
505
+ }
506
+ }
507
+ ), TestMMContextSensitiveCommands)
508
+ assert_no_problems(problems)
509
+ root = env.find(:class => TestMMContextSensitiveCommands::TestNode).first
510
+ assert root != nil
511
+ assert(root.command.is_a?(TestMMContextSensitiveCommands::SubPackage1::Command))
512
+ assert(root.command.command.is_a?(TestMMContextSensitiveCommands::SubPackage2::Command))
513
+ end
514
+
515
+ def test_context_sensitive_command_name_mapping
516
+ env, problems = instantiate(%Q(
517
+ Command {
518
+ Command {
519
+ Command
520
+ }
521
+ }
522
+ ), TestMMContextSensitiveCommands, :command_name_provider => lambda do |c|
523
+ "Command" end)
524
+ assert_no_problems(problems)
525
+ root = env.find(:class => TestMMContextSensitiveCommands::TestNode).first
526
+ assert root != nil
527
+ assert(root.command.is_a?(TestMMContextSensitiveCommands::SubPackage1::Command))
528
+ assert(root.command.command.is_a?(TestMMContextSensitiveCommands::SubPackage2::Command))
529
+ end
530
+
531
+ #
532
+ # problems
533
+ #
534
+
535
+ def test_unexpected_end_of_file
536
+ env, problems = instantiate(%Q(
537
+ TestNode text: "some text" {
538
+ ), TestMM)
539
+ assert_problems([[/unexpected end of file, expected \}/i, 2]], problems)
540
+ end
541
+
542
+ def test_unknown_command
543
+ env, problems = instantiate(%Q(
544
+ NotDefined
545
+ ), TestMM)
546
+ assert_problems([[/unknown command 'NotDefined'/i, 2]], problems)
547
+ end
548
+
549
+ def test_unknown_command_abstract
550
+ env, problems = instantiate(%Q(
551
+ TestNode
552
+ ), TestMMAbstract)
553
+ assert_problems([[/unknown command 'TestNode'/i, 2]], problems)
554
+ end
555
+
556
+ def test_unexpected_unlabled_argument
557
+ env, problems = instantiate(%Q(
558
+ TestNode "more text"
559
+ ), TestMM)
560
+ assert_problems([[/unexpected unlabled argument, 0 unlabled arguments expected/i, 2]], problems)
561
+ end
562
+
563
+ def test_unknown_child_role
564
+ env, problems = instantiate(%Q(
565
+ TestNode {
566
+ notdefined:
567
+ TestNode
568
+ }
569
+ ), TestMM)
570
+ assert_problems([[/unknown child role 'notdefined'/i, 3]], problems)
571
+ end
572
+
573
+ def test_not_a_child_role
574
+ env, problems = instantiate(%Q(
575
+ TestNode {
576
+ text:
577
+ TestNode
578
+ others:
579
+ TestNode
580
+ }
581
+ ), TestMM)
582
+ assert_problems([
583
+ [/role 'text' can not take child elements/i, 3],
584
+ [/role 'others' can not take child elements/i, 5]
585
+ ], problems)
586
+ end
587
+
588
+ def test_not_a_single_child
589
+ env, problems = instantiate(%Q(
590
+ TestNode {
591
+ singleChild: [
592
+ TestNode
593
+ TestNode
594
+ ]
595
+ }
596
+ ), TestMM2)
597
+ assert_problems([
598
+ [/only one child allowed in role 'singleChild'/i, 5]
599
+ ], problems)
600
+ end
601
+
602
+ def test_not_a_single_child2
603
+ env, problems = instantiate(%Q(
604
+ TestNode {
605
+ singleChild:
606
+ TestNode
607
+ singleChild: [
608
+ ]
609
+ singleChild:
610
+ TestNode
611
+ }
612
+ ), TestMM2)
613
+ assert_problems([
614
+ [/only one child allowed in role 'singleChild'/i, 8]
615
+ ], problems)
616
+ end
617
+
618
+ def test_wrong_child_role
619
+ env, problems = instantiate(%Q(
620
+ TestNode {
621
+ singleChild:
622
+ TestNode2
623
+ }
624
+ ), TestMM2)
625
+ assert_problems([
626
+ [/role 'singleChild' can not take a TestNode2, expected TestNode/i, 4]
627
+ ], problems)
628
+ end
629
+
630
+ def test_child_role_without_child
631
+ env, problems = instantiate(%Q(
632
+ TestNode {
633
+ singleChild:
634
+ }
635
+ ), TestMM2)
636
+ assert_problems([
637
+ [/unexpected \}, expected identifier/i, 4]
638
+ ], problems)
639
+ end
640
+
641
+ def test_wrong_child
642
+ env, problems = instantiate(%Q(
643
+ TestNode {
644
+ TestNode3
645
+ }
646
+ ), TestMM2)
647
+ assert_problems([
648
+ [/command 'TestNode3' can not be used in this context/i, 3]
649
+ ], problems)
650
+ end
651
+
652
+ def test_ambiguous_child_role
653
+ env, problems = instantiate(%Q(
654
+ TestNode {
655
+ TestNode2
656
+ }
657
+ ), TestMM2)
658
+ assert_problems([
659
+ [/role of element is ambiguous, use a role label/i, 3]
660
+ ], problems)
661
+ end
662
+
663
+ def test_non_ambiguous_child_role_subclass
664
+ env, problems = instantiate(%Q(
665
+ TestNode {
666
+ TestNode4
667
+ }
668
+ ), TestMM2)
669
+ assert_no_problems(problems)
670
+ end
671
+
672
+ def test_not_a_single_child3
673
+ env, problems = instantiate(%Q(
674
+ TestNode {
675
+ TestNode
676
+ TestNode
677
+ }
678
+ ), TestMM2)
679
+ assert_problems([
680
+ [/only one child allowed in role 'singleChild'/i, 4]
681
+ ], problems)
682
+ end
683
+
684
+ def test_unknown_argument
685
+ env, problems = instantiate(%Q(
686
+ TestNode unknown: "some text"
687
+ ), TestMM)
688
+ assert_problems([[/unknown argument 'unknown'/i, 2]], problems)
689
+ end
690
+
691
+ def test_attribute_in_child_reference
692
+ env, problems = instantiate(%Q(
693
+ TestNode singleChild: "some text"
694
+ ), TestMM2)
695
+ assert_problems([[/argument 'singleChild' can only take child elements/i, 2]], problems)
696
+ end
697
+
698
+ def test_arguments_duplicate
699
+ env, problems = instantiate(%Q(
700
+ TestNode text: "some text", text: "more text"
701
+ ), TestMM)
702
+ assert_problems([[/argument 'text' already defined/i, 2]], problems)
703
+ end
704
+
705
+ def test_unlabled_arguments_duplicate
706
+ env, problems = instantiate(%Q(
707
+ TestNode text: "some text", "more text"
708
+ ), TestMM, :unlabled_arguments => proc {|c| ["text"]})
709
+ assert_problems([[/argument 'text' already defined/i, 2]], problems)
710
+ end
711
+
712
+ def test_multiple_arguments_in_non_many_attribute
713
+ env, problems = instantiate(%Q(
714
+ TestNode text: ["text1", "text2"]
715
+ ), TestMM)
716
+ assert_problems([[/argument 'text' can take only one value/i, 2]], problems)
717
+ end
718
+
719
+ def test_wrong_argument_type
720
+ env, problems = instantiate(%Q(
721
+ TestNode text: 1
722
+ TestNode integer: "text"
723
+ TestNode integer: true
724
+ TestNode integer: 1.2
725
+ TestNode integer: a
726
+ TestNode integer: /a
727
+ TestNode enum: 1
728
+ TestNode enum: x
729
+ TestNode related: 1
730
+ ), TestMM)
731
+ assert_problems([
732
+ [/argument 'text' can not take a integer, expected string/i, 2],
733
+ [/argument 'integer' can not take a string, expected integer/i, 3],
734
+ [/argument 'integer' can not take a boolean, expected integer/i, 4],
735
+ [/argument 'integer' can not take a float, expected integer/i, 5],
736
+ [/argument 'integer' can not take a identifier, expected integer/i, 6],
737
+ [/argument 'integer' can not take a reference, expected integer/i, 7],
738
+ [/argument 'enum' can not take a integer, expected identifier/i, 8],
739
+ [/argument 'enum' can not take value x, expected A, B/i, 9],
740
+ [/argument 'related' can not take a integer, expected reference, identifier/i, 10]
741
+ ], problems)
742
+ end
743
+
744
+ def test_missing_opening_brace
745
+ env, problems = instantiate(%Q(
746
+ TestNode
747
+ }
748
+ ), TestMM)
749
+ assert_problems([[/unexpected \}, expected identifier/i, 3]], problems)
750
+ end
751
+
752
+ def test_invalid_root
753
+ env, problems = instantiate(%Q(
754
+ NonRootClass
755
+ ), TestMMNonRootClass)
756
+ assert_problems([[/command 'NonRootClass' can not be used on root level/i, 2]], problems)
757
+ end
758
+
759
+ def test_invalid_root_label
760
+ root_elements = []
761
+ env, problems = instantiate(%Q(
762
+ TestNode text : A
763
+ ), TestMM, :root_elements => root_elements)
764
+ assert_problems([
765
+ [/Unexpected unlabled argument, 0 unlabled arguments expected/i, 2],
766
+ [/Unexpected :, expected newline/i, 2]
767
+ ], problems)
768
+ end
769
+
770
+ #
771
+ # problem recovery
772
+ #
773
+
774
+ def test_missing_value
775
+ root_elements = []
776
+ env, problems = instantiate(%Q(
777
+ TestNode nums: 1, text:
778
+ TestNode nums: 2, text: {
779
+ SubNode
780
+ }
781
+ TestNode text: ,nums: 3 {
782
+ SubNode
783
+ }
784
+ TestNode nums: , text: , bla:
785
+ ), TestMM, :root_elements => root_elements)
786
+ assert_equal 4, root_elements.size
787
+ assert_equal [1], root_elements[0].nums
788
+ assert_nil root_elements[0].text
789
+ assert_equal [2], root_elements[1].nums
790
+ assert_equal 1, root_elements[1].childs.size
791
+ assert_equal [3], root_elements[2].nums
792
+ assert_equal 1, root_elements[2].childs.size
793
+ assert_problems([
794
+ [/unexpected newline, expected.*integer/i, 2],
795
+ [/unexpected \{, expected.*integer/i, 3],
796
+ [/unexpected ,, expected.*integer/i, 6],
797
+ [/unexpected ,, expected.*integer/i, 9],
798
+ [/unexpected ,, expected.*integer/i, 9],
799
+ [/unexpected newline, expected.*integer/i, 9],
800
+ [/unknown argument 'bla'/i, 9],
801
+ ], problems)
802
+ end
803
+
804
+ def test_missing_comma
805
+ root_elements = []
806
+ env, problems = instantiate(%Q(
807
+ TestNode nums: 1 text: "bla"
808
+ ), TestMM, :root_elements => root_elements)
809
+ assert_equal 1, root_elements.size
810
+ assert_equal [1], root_elements[0].nums
811
+ assert_equal "bla", root_elements[0].text
812
+ assert_problems([
813
+ [/unexpected label .*, expected ,/i, 2],
814
+ ], problems)
815
+ end
816
+
817
+ def test_missing_label
818
+ root_elements = []
819
+ env, problems = instantiate(%Q(
820
+ TestNode nums: 1 "bla"
821
+ ), TestMM, :root_elements => root_elements)
822
+ assert_equal 1, root_elements.size
823
+ assert_equal [1], root_elements[0].nums
824
+ assert_problems([
825
+ [/unexpected string 'bla', expected ,/i, 2],
826
+ [/unexpected unlabled argument/i, 2]
827
+ ], problems)
828
+ end
829
+
830
+ def test_unclosed_bracket1
831
+ root_elements = []
832
+ env, problems = instantiate(%Q(
833
+ TestNode nums: [1, "bla"
834
+ ), TestMM, :root_elements => root_elements)
835
+ assert_equal 1, root_elements.size
836
+ assert_equal [1], root_elements[0].nums
837
+ assert_nil root_elements[0].text
838
+ assert_problems([
839
+ [/unexpected newline, expected \]/i, 2],
840
+ [/argument 'nums' can not take a string, expected integer/i, 2],
841
+ ], problems)
842
+ end
843
+
844
+ def test_unclosed_bracket2
845
+ root_elements = []
846
+ env, problems = instantiate(%Q(
847
+ TestNode nums: [1, text: "bla"
848
+ ), TestMM, :root_elements => root_elements)
849
+ assert_equal 1, root_elements.size
850
+ assert_equal [1], root_elements[0].nums
851
+ assert_equal "bla", root_elements[0].text
852
+ assert_problems([
853
+ [/unexpected label 'text', expected identifier/i, 2],
854
+ ], problems)
855
+ end
856
+
857
+ def test_unclosed_bracket3
858
+ root_elements = []
859
+ env, problems = instantiate(%Q(
860
+ TestNode nums: [1 text: "bla"
861
+ ), TestMM, :root_elements => root_elements)
862
+ assert_equal 1, root_elements.size
863
+ assert_equal [1], root_elements[0].nums
864
+ assert_equal "bla", root_elements[0].text
865
+ assert_problems([
866
+ [/unexpected label 'text', expected \]/i, 2],
867
+ ], problems)
868
+ end
869
+
870
+ def test_unclosed_bracket4
871
+ root_elements = []
872
+ env, problems = instantiate(%Q(
873
+ TestNode nums: [1 "bla"
874
+ ), TestMM, :root_elements => root_elements)
875
+ assert_equal 1, root_elements.size
876
+ assert_equal [1], root_elements[0].nums
877
+ assert_nil root_elements[0].text
878
+ assert_problems([
879
+ [/unexpected string 'bla', expected ,/i, 2],
880
+ [/argument 'nums' can not take a string, expected integer/i, 2],
881
+ [/unexpected newline, expected \]/i, 2],
882
+ ], problems)
883
+ end
884
+
885
+ def test_unclosed_bracket5
886
+ root_elements = []
887
+ env, problems = instantiate(%Q(
888
+ TestNode [1, "bla"
889
+ ), TestMM, :root_elements => root_elements)
890
+ assert_equal 1, root_elements.size
891
+ assert_equal [], root_elements[0].nums
892
+ assert_nil root_elements[0].text
893
+ assert_problems([
894
+ [/unexpected newline, expected \]/i, 2],
895
+ [/unexpected unlabled argument/i, 2],
896
+ ], problems)
897
+ end
898
+
899
+ def test_unclosed_bracket6
900
+ root_elements = []
901
+ env, problems = instantiate(%Q(
902
+ TestNode [1, "bla" [
903
+ ), TestMM, :root_elements => root_elements)
904
+ assert_equal 1, root_elements.size
905
+ assert_problems([
906
+ [/unexpected \[, expected \]/i, 2],
907
+ [/unexpected end of file, expected \]/i, 2],
908
+ [/unexpected unlabled argument/i, 2],
909
+ [/unexpected unlabled argument/i, 2],
910
+ ], problems)
911
+ end
912
+
913
+ def test_unclosed_bracket7
914
+ root_elements = []
915
+ env, problems = instantiate(%Q(
916
+ TestNode [1, "bla", [
917
+ ), TestMM, :root_elements => root_elements)
918
+ assert_equal 1, root_elements.size
919
+ assert_problems([
920
+ [/unexpected \[, expected identifier/i, 2],
921
+ [/unexpected unlabled argument/i, 2],
922
+ [/unexpected unlabled argument/i, 2],
923
+ [/unexpected end of file, expected \]/i, 2],
924
+ ], problems)
925
+ end
926
+
927
+ def test_closing_bracket
928
+ root_elements = []
929
+ env, problems = instantiate(%Q(
930
+ TestNode ]
931
+ TestNode 1 ]
932
+ TestNode 1, ]
933
+ TestNode nums: ]1, "bla"
934
+ TestNode text: "bla" ]
935
+ ), TestMM, :root_elements => root_elements)
936
+ assert_equal 5, root_elements.size
937
+ assert_equal [], root_elements[3].nums
938
+ assert_equal "bla", root_elements[4].text
939
+ assert_problems([
940
+ [/unexpected \], expected newline/i, 2],
941
+ [/unexpected \], expected newline/i, 3],
942
+ [/unexpected unlabled argument/i, 3],
943
+ [/unexpected \], expected identifier/i, 4],
944
+ [/unexpected unlabled argument/i, 4],
945
+ [/unexpected \], expected identifier/i, 5],
946
+ [/unexpected \], expected newline/i, 6],
947
+ ], problems)
948
+ end
949
+
950
+ def test_closing_brace
951
+ root_elements = []
952
+ env, problems = instantiate(%Q(
953
+ TestNode }
954
+ TestNode 1 }
955
+ TestNode 1, }
956
+ TestNode nums: }1, "bla"
957
+ TestNode text: "bla" }
958
+ ), TestMM, :root_elements => root_elements)
959
+ assert_equal 5, root_elements.size
960
+ assert_equal [], root_elements[3].nums
961
+ assert_equal "bla", root_elements[4].text
962
+ assert_problems([
963
+ [/unexpected \}, expected newline/i, 2],
964
+ [/unexpected \}, expected newline/i, 3],
965
+ [/unexpected unlabled argument/i, 3],
966
+ [/unexpected \}, expected identifier/i, 4],
967
+ [/unexpected unlabled argument/i, 4],
968
+ [/unexpected \}, expected identifier/i, 5],
969
+ [/unexpected \}, expected newline/i, 6],
970
+ ], problems)
971
+ end
972
+
973
+ def test_starting_non_command
974
+ root_elements = []
975
+ env, problems = instantiate(%Q(
976
+ \)
977
+ TestNode
978
+ *
979
+ TestNode
980
+ $
981
+ TestNode
982
+ ,
983
+ TestNode
984
+ [
985
+ TestNode
986
+ {
987
+ TestNode
988
+ ]
989
+ TestNode
990
+ }
991
+ TestNode
992
+ }}
993
+ ), TestMM, :root_elements => root_elements)
994
+ assert_equal 8, root_elements.size
995
+ assert_problems([
996
+ [/parse error on token '\)'/i, 2],
997
+ [/parse error on token '\*'/i, 4],
998
+ [/parse error on token '\$'/i, 6],
999
+ [/unexpected ,, expected identifier/i, 8],
1000
+ [/unexpected \[, expected identifier/i, 10],
1001
+ [/unexpected \{, expected identifier/i, 12],
1002
+ [/unexpected \], expected identifier/i, 14],
1003
+ [/unexpected \}, expected identifier/i, 16],
1004
+ [/unexpected \}, expected identifier/i, 18],
1005
+ ], problems)
1006
+ end
1007
+
1008
+ def test_parse_error_in_argument_list
1009
+ root_elements = []
1010
+ env, problems = instantiate(%Q(
1011
+ TestNode text: "bla", * nums: 1
1012
+ TestNode text: "bla" * , nums: 1
1013
+ TestNode ?text: "bla"
1014
+ TestNode nums: [1, * 3]
1015
+ ), TestMM, :root_elements => root_elements)
1016
+ assert_equal 4, root_elements.size
1017
+ assert_equal "bla", root_elements[0].text
1018
+ assert_equal [1], root_elements[0].nums
1019
+ assert_equal "bla", root_elements[1].text
1020
+ assert_equal [1], root_elements[1].nums
1021
+ assert_equal "bla", root_elements[2].text
1022
+ assert_equal [1, 3], root_elements[3].nums
1023
+ assert_problems([
1024
+ [/parse error on token '\*'/i, 2],
1025
+ [/parse error on token '\*'/i, 3],
1026
+ [/parse error on token '\?'/i, 4],
1027
+ [/parse error on token '\*'/i, 5],
1028
+ ], problems)
1029
+ end
1030
+
1031
+ def test_unclosed_brace
1032
+ root_elements = []
1033
+ env, problems = instantiate(%Q(
1034
+ TestNode {
1035
+ ), TestMM, :root_elements => root_elements)
1036
+ assert_equal 1, root_elements.size
1037
+ assert_problems([
1038
+ [/unexpected end of file, expected \}/i, 2]
1039
+ ], problems)
1040
+ end
1041
+
1042
+ def test_unclosed_brace2
1043
+ root_elements = []
1044
+ env, problems = instantiate(%Q(
1045
+ TestNode {
1046
+ *
1047
+ ), TestMM, :root_elements => root_elements)
1048
+ assert_equal 1, root_elements.size
1049
+ assert_problems([
1050
+ [/parse error on token '\*'/i, 3]
1051
+ ], problems)
1052
+ end
1053
+
1054
+ def test_unclosed_brace3
1055
+ root_elements = []
1056
+ env, problems = instantiate(%Q(
1057
+ TestNode {
1058
+ childs:
1059
+ ), TestMM, :root_elements => root_elements)
1060
+ assert_equal 1, root_elements.size
1061
+ assert_problems([
1062
+ [/unexpected end of file, expected identifier/i, 3]
1063
+ ], problems)
1064
+ end
1065
+
1066
+ def test_label_without_child
1067
+ root_elements = []
1068
+ env, problems = instantiate(%Q(
1069
+ TestNode {
1070
+ childs:
1071
+ }
1072
+ ), TestMM, :root_elements => root_elements)
1073
+ assert_equal 1, root_elements.size
1074
+ assert_problems([
1075
+ [/unexpected \}, expected identifier/i, 4]
1076
+ ], problems)
1077
+ end
1078
+
1079
+ def test_unclosed_child_bracket
1080
+ root_elements = []
1081
+ env, problems = instantiate(%Q(
1082
+ TestNode {
1083
+ childs: [
1084
+ ), TestMM, :root_elements => root_elements)
1085
+ assert_equal 1, root_elements.size
1086
+ assert_problems([
1087
+ [/unexpected end of file, expected \]/i, 3]
1088
+ ], problems)
1089
+ end
1090
+
1091
+ def test_child_label_problems
1092
+ root_elements = []
1093
+ env, problems = instantiate(%Q(
1094
+ TestNode {
1095
+ childs: x
1096
+ SubNode
1097
+ childs: *
1098
+ SubNode
1099
+ childs: &
1100
+ }
1101
+ ), TestMM, :root_elements => root_elements)
1102
+ assert_equal 1, root_elements.size
1103
+ assert_equal 2, root_elements[0].childs.size
1104
+ assert_problems([
1105
+ [/unexpected identifier 'x', expected newline/i, 3],
1106
+ [/parse error on token '\*'/i, 5],
1107
+ [/parse error on token '&'/i, 7]
1108
+ ], problems)
1109
+ end
1110
+
1111
+ def test_child_label_problems_with_bracket
1112
+ root_elements = []
1113
+ env, problems = instantiate(%Q(
1114
+ TestNode {
1115
+ childs: [ x
1116
+ SubNode
1117
+ ]
1118
+ childs: [ *
1119
+ SubNode
1120
+ ]
1121
+ childs: [&
1122
+ ]
1123
+ }
1124
+ ), TestMM, :root_elements => root_elements)
1125
+ assert_equal 1, root_elements.size
1126
+ assert_equal 2, root_elements[0].childs.size
1127
+ assert_problems([
1128
+ [/unexpected identifier 'x', expected newline/i, 3],
1129
+ [/parse error on token '\*'/i, 6],
1130
+ [/parse error on token '&'/i, 9]
1131
+ ], problems)
1132
+ end
1133
+
1134
+ def test_missing_closing_bracket
1135
+ root_elements = []
1136
+ env, problems = instantiate(%Q(
1137
+ TestNode {
1138
+ childs: [
1139
+ SubNode
1140
+ childs: [
1141
+ SubNode
1142
+ SubNode
1143
+ }
1144
+ ), TestMM, :root_elements => root_elements)
1145
+ assert_equal 1, root_elements.size
1146
+ assert_equal 3, root_elements[0].childs.size
1147
+ assert_problems([
1148
+ [/unexpected label 'childs', expected identifier/i, 5],
1149
+ [/unexpected \}, expected identifier/i, 8],
1150
+ ], problems)
1151
+ end
1152
+
1153
+ def test_missing_closing_brace
1154
+ root_elements = []
1155
+ env, problems = instantiate(%Q(
1156
+ TestNode {
1157
+ TestNode {
1158
+ TestNode
1159
+ }
1160
+ ), TestMM, :root_elements => root_elements)
1161
+ assert_equal 1, root_elements.size
1162
+ assert_equal 1, root_elements[0].childs.size
1163
+ assert_equal 1, root_elements[0].childs[0].childs.size
1164
+ assert_problems([
1165
+ [/unexpected end of file, expected \}/i, 5],
1166
+ ], problems)
1167
+ end
1168
+
1169
+ #
1170
+ # command name provider
1171
+ #
1172
+
1173
+ def test_command_name_provider
1174
+ env, problems = instantiate(%Q(
1175
+ TestNodeX text: "some text", nums: [1,2] {
1176
+ TestNodeX text: "child"
1177
+ TestNodeX text: "child2"
1178
+ }
1179
+ ), TestMM, :command_name_provider => proc do |c|
1180
+ c.name + "X"
1181
+ end)
1182
+ assert_no_problems(problems)
1183
+ assert_model_simple(env, :with_nums)
1184
+ end
1185
+
1186
+ def test_command_name_provider_ambiguous
1187
+ begin
1188
+ env, problems = instantiate(%Q(
1189
+ TestNode
1190
+ ), TestMM, :command_name_provider => proc do |c|
1191
+ "Fixed"
1192
+ end)
1193
+ assert false
1194
+ rescue RuntimeError => e
1195
+ assert e.message =~ /ambiguous command name/
1196
+ end
1197
+ end
1198
+
1199
+ #
1200
+ # comment handler
1201
+ #
1202
+
1203
+ def test_comment_handler
1204
+ proc_calls = 0
1205
+ env, problems = instantiate(%Q(
1206
+ #comment
1207
+ TestNode text: "node1"
1208
+ #comment
1209
+ # multiline
1210
+ TestNode text: "node2"
1211
+ TestNode text: "node3" #comment
1212
+ #above
1213
+ TestNode text: "node4" {#right1
1214
+ childs: [ #right2
1215
+ #unassociated1
1216
+ ] #right3
1217
+ #unassociated2
1218
+ } #below
1219
+ #above1
1220
+ #above2
1221
+ TestNode text: "node5" { #right1
1222
+ childs: #right2
1223
+ TestNode
1224
+ }#below
1225
+ #comment without
1226
+ #an element following
1227
+ ), TestMM, :comment_handler => proc {|c,k,e,env|
1228
+ proc_calls += 1
1229
+ if e.nil?
1230
+ case proc_calls
1231
+ when 4
1232
+ assert_equal "unassociated1", c
1233
+ assert_equal :unassociated, k
1234
+ when 5
1235
+ assert_equal "unassociated2", c
1236
+ assert_equal :unassociated, k
1237
+ when 15
1238
+ assert_equal "comment without\nan element following", c
1239
+ assert_equal :unassociated, k
1240
+ end
1241
+ elsif e.text == "node1"
1242
+ assert_equal "comment", c
1243
+ assert_equal :above, k
1244
+ elsif e.text == "node2"
1245
+ assert_equal "comment\n multiline", c
1246
+ assert_equal :above, k
1247
+ elsif e.text == "node3"
1248
+ assert_equal "comment", c
1249
+ assert_equal :eol, k
1250
+ elsif e.text == "node4"
1251
+ case proc_calls
1252
+ when 6
1253
+ assert_equal "above", c
1254
+ assert_equal :above, k
1255
+ when 7
1256
+ assert_equal "right1", c
1257
+ assert_equal :eol, k
1258
+ when 8
1259
+ assert_equal "right2", c
1260
+ assert_equal :eol, k
1261
+ when 9
1262
+ assert_equal "right3", c
1263
+ assert_equal :eol, k
1264
+ when 10
1265
+ assert_equal "below", c
1266
+ assert_equal :eol, k
1267
+ end
1268
+ elsif e.text == "node5"
1269
+ case proc_calls
1270
+ when 11
1271
+ assert_equal "above1\nabove2", c
1272
+ assert_equal :above, k
1273
+ when 12
1274
+ assert_equal "right1", c
1275
+ assert_equal :eol, k
1276
+ when 13
1277
+ assert_equal "right2", c
1278
+ assert_equal :eol, k
1279
+ when 14
1280
+ assert_equal "below", c
1281
+ assert_equal :eol, k
1282
+ end
1283
+ else
1284
+ assert false, "unexpected element in comment handler"
1285
+ end
1286
+ true
1287
+ })
1288
+ assert_no_problems(problems)
1289
+ assert_equal 15, proc_calls
1290
+ end
1291
+
1292
+ def test_comment_handler_comment_not_allowed
1293
+ env, problems = instantiate(%Q(
1294
+ #comment
1295
+ TestNode
1296
+ ), TestMM, :comment_handler => proc {|c,k,e,env|
1297
+ false
1298
+ })
1299
+ assert_problems([[/element can not take this comment/, 3]], problems)
1300
+ end
1301
+
1302
+ def test_comment_handler_comment_not_allowed_unassociated
1303
+ env, problems = instantiate(%Q(
1304
+ #comment
1305
+ ), TestMM, :comment_handler => proc {|c,k,e,env|
1306
+ false
1307
+ })
1308
+ assert_problems([[/Unassociated comment not allowed/, 2]], problems)
1309
+ end
1310
+
1311
+ #
1312
+ # annotations
1313
+ #
1314
+
1315
+ def test_annotation_not_supported
1316
+ env, problems = instantiate(%Q(
1317
+ @annotation
1318
+ TestNode
1319
+ ), TestMM)
1320
+ assert_problems([[/annotation not allowed/i, 3]], problems)
1321
+ end
1322
+
1323
+ def test_annotation_not_allowed
1324
+ env, problems = instantiate(%Q(
1325
+ @annotation
1326
+ TestNode
1327
+ ), TestMM, :annotation_handler => proc {|a,e,env|
1328
+ false
1329
+ })
1330
+ assert_problems([[/annotation not allowed/i, 3]], problems)
1331
+ end
1332
+
1333
+ def test_annotation_in_wrong_places
1334
+ env, problems = instantiate(%Q(
1335
+ @annotation
1336
+ #comment
1337
+ TestNode {
1338
+ @annotation
1339
+ childs:
1340
+ TestNode
1341
+ @annotation
1342
+ }
1343
+ @annotation
1344
+ ), TestMM)
1345
+ assert_problems([
1346
+ [/unexpected comment 'comment', expected identifier/i, 3],
1347
+ [/unexpected label 'childs', expected identifier/i, 6],
1348
+ [/unexpected \}, expected identifier/i, 9],
1349
+ [/unexpected end of file, expected identifier/i, 10]
1350
+ ], problems)
1351
+ end
1352
+
1353
+ def test_annotation_handler
1354
+ annotations = []
1355
+ elements = []
1356
+ env, problems = instantiate(%Q(
1357
+ @annotation
1358
+ TestNode text: "aa"
1359
+ @annotation
1360
+ @ in a new line
1361
+
1362
+ @ even with space in between
1363
+
1364
+ TestNode text: "bb" {
1365
+ @at child
1366
+ TestNode text: "cc"
1367
+ childs:
1368
+ @after label
1369
+ TestNode text: "dd"
1370
+ @another child
1371
+ TestNode text: "ee"
1372
+ childs: [
1373
+ @in brackets
1374
+ TestNode text: "ff"
1375
+ ]
1376
+ }
1377
+ ), TestMM, :annotation_handler => proc {|a,e,env|
1378
+ annotations << a
1379
+ elements << e
1380
+ true
1381
+ })
1382
+ assert_equal "aa", elements[0].text
1383
+ assert_equal "annotation", annotations[0]
1384
+ assert_equal "cc", elements[1].text
1385
+ assert_equal "at child", annotations[1]
1386
+ assert_equal "dd", elements[2].text
1387
+ assert_equal "after label", annotations[2]
1388
+ assert_equal "ee", elements[3].text
1389
+ assert_equal "another child", annotations[3]
1390
+ assert_equal "ff", elements[4].text
1391
+ assert_equal "in brackets", annotations[4]
1392
+ assert_equal "bb", elements[5].text
1393
+ assert_equal "annotation\n in a new line\n even with space in between", annotations[5]
1394
+ assert_no_problems(problems)
1395
+ end
1396
+
1397
+ #
1398
+ # generics
1399
+ #
1400
+
1401
+ def test_generics_parse_error
1402
+ env, problems = instantiate(%Q(
1403
+ TestNode text: <bla
1404
+ TestNode text: bla>
1405
+ TestNode text: <a<b>
1406
+ TestNode text: <a>b>
1407
+ TestNode text: <%a
1408
+ TestNode text: <%a%
1409
+ TestNode text: <%a%>b%>
1410
+ ), TestMM, :enable_generics => true)
1411
+ assert_problems([
1412
+ [/parse error on token '<'/i, 2],
1413
+ [/unexpected unlabled argument/i, 2],
1414
+ [/parse error on token '>'/i, 3],
1415
+ [/unexpected identifier 'b'/i, 5],
1416
+ [/parse error on token '>'/i, 5],
1417
+ [/unexpected unlabled argument/i, 5],
1418
+ [/parse error on token '<'/i, 6],
1419
+ [/unexpected unlabled argument/i, 6],
1420
+ [/parse error on token '<'/i, 7],
1421
+ [/unexpected unlabled argument/i, 7],
1422
+ [/parse error on token '%'/i, 7],
1423
+ [/unexpected identifier 'b'/i, 8],
1424
+ [/unexpected unlabled argument/i, 8],
1425
+ [/parse error on token '%'/i, 8],
1426
+ ], problems)
1427
+ end
1428
+
1429
+ def test_generics
1430
+ root_elements = []
1431
+ env, problems = instantiate(%q(
1432
+ TestNode text: <bla>, nums: [<1>, <%2%>], boolean: <truthy>, enum: <%option%>, float: <precise>, related: <%noderef%>, others: [<other1>, <%other2%>]
1433
+ ), TestMM, :root_elements => root_elements, :enable_generics => true)
1434
+ assert_no_problems(problems)
1435
+ assert root_elements[0].text.is_a?(RText::Generic)
1436
+ assert_equal "bla", root_elements[0].text.string
1437
+ assert_equal ["1", "2"], root_elements[0].nums.collect{|n| n.string}
1438
+ assert_equal "truthy", root_elements[0].boolean.string
1439
+ assert_equal "option", root_elements[0].enum.string
1440
+ assert_equal "precise", root_elements[0].float.string
1441
+ assert_equal "noderef", root_elements[0].related.string
1442
+ assert_equal ["other1", "other2"], root_elements[0].others.collect{|n| n.string}
1443
+ end
1444
+
1445
+ def test_generics_forbidden
1446
+ env, problems = instantiate(%Q(\
1447
+ TestNode text: <bla>
1448
+ ), TestMM)
1449
+ assert_problems([
1450
+ [/generic value not allowed/i, 1],
1451
+ ], problems)
1452
+ end
1453
+
1454
+ #
1455
+ # subpackages
1456
+ #
1457
+
1458
+ def test_subpackage
1459
+ env, problems = instantiate(%q(
1460
+ TestNodeSub text: "something"
1461
+ ), TestMMSubpackage)
1462
+ assert_no_problems(problems)
1463
+ assert_equal "something", env.elements.first.text
1464
+ end
1465
+
1466
+ #
1467
+ # values
1468
+ #
1469
+
1470
+ def test_escapes
1471
+ env, problems = instantiate(%q(
1472
+ TestNode text: "some \" \\\\ \\\\\" text \r xx \n xx \r\n xx \t xx \b xx \f"
1473
+ ), TestMM)
1474
+ assert_no_problems(problems)
1475
+ assert_equal %Q(some " \\ \\" text \r xx \n xx \r\n xx \t xx \b xx \f), env.elements.first.text
1476
+ end
1477
+
1478
+ def test_escape_single_backslash
1479
+ env, problems = instantiate(%q(
1480
+ TestNode text: "a single \\ will be just itself"
1481
+ ), TestMM)
1482
+ assert_no_problems(problems)
1483
+ assert_equal %q(a single \\ will be just itself), env.elements.first.text
1484
+ end
1485
+
1486
+ def test_string_umlauts
1487
+ env, problems = instantiate(%q(
1488
+ TestNode text: "ä, ö, ü"
1489
+ ), TestMM)
1490
+ assert_no_problems(problems)
1491
+ assert_equal %q(ä, ö, ü), env.elements.first.text
1492
+ end
1493
+
1494
+ def test_integer
1495
+ env, problems = instantiate(%q(
1496
+ TestNode integer: 7
1497
+ TestNode integer: 4294967296
1498
+ TestNode integer: 12345678901234567890
1499
+ ), TestMM)
1500
+ assert_no_problems(problems)
1501
+ assert_equal 7, env.elements[0].integer
1502
+ assert_equal 4294967296, env.elements[1].integer
1503
+ assert_equal 12345678901234567890, env.elements[2].integer
1504
+ end
1505
+
1506
+ def test_integer_hex
1507
+ env, problems = instantiate(%q(
1508
+ TestNode text: root {
1509
+ TestNode integer: 0x7
1510
+ TestNode integer: 0X7
1511
+ TestNode integer: 0x007
1512
+ TestNode integer: 0x77
1513
+ TestNode integer: 0xabCDEF
1514
+ TestNode integer: 0xabcdefabcdefabcdef
1515
+ }
1516
+ ), TestMM)
1517
+ assert_no_problems(problems)
1518
+ assert_equal [7, 7, 7, 0x77, 0xABCDEF, 0xabcdefabcdefabcdef], env.find(:text => "root").first.childs.collect{|c| c.integer}
1519
+ end
1520
+
1521
+ def test_float
1522
+ env, problems = instantiate(%q(
1523
+ TestNode float: 1.23
1524
+ TestNode float: 1.23e-08
1525
+ TestNode float: 1.23e+10
1526
+ TestNode float: 1234567890.123456789
1527
+ ), TestMM)
1528
+ assert_no_problems(problems)
1529
+ assert_equal 1.23, env.elements[0].float
1530
+ assert_equal 1.23e-08, env.elements[1].float
1531
+ assert_equal 1.23e+10, env.elements[2].float
1532
+ if rgen_with_bigdecimal?
1533
+ assert env.elements[3].float.is_a?(BigDecimal)
1534
+ assert_equal "1234567890.123456789", env.elements[3].float.to_s("F")
1535
+ else
1536
+ assert env.elements[3].float.is_a?(Float)
1537
+ assert_equal "1234567890.1234567", env.elements[3].float.to_s
1538
+ end
1539
+ end
1540
+
1541
+ def test_boolean
1542
+ env, problems = instantiate(%q(
1543
+ TestNode text: root {
1544
+ TestNode boolean: true
1545
+ TestNode boolean: false
1546
+ }
1547
+ ), TestMM)
1548
+ assert_no_problems(problems)
1549
+ assert_equal [true, false], env.find(:text => "root").first.childs.collect{|c| c.boolean}
1550
+ end
1551
+
1552
+ def test_enum
1553
+ env, problems = instantiate(%q(
1554
+ TestNode text: root {
1555
+ TestNode enum: A
1556
+ TestNode enum: B
1557
+ TestNode enum: "non-word*chars"
1558
+ TestNode enum: "2you"
1559
+ }
1560
+ ), TestMM)
1561
+ assert_no_problems(problems)
1562
+ assert_equal [:A, :B, :'non-word*chars', :'2you'], env.find(:text => "root").first.childs.collect{|c| c.enum}
1563
+ end
1564
+
1565
+ def test_with_bom
1566
+ env, problems = instantiate(%Q(\xEF\xBB\xBF
1567
+ TestNode text: "some text", nums: [1,2] {
1568
+ TestNode text: "child"
1569
+ TestNode text: "child2"
1570
+ }
1571
+ ), TestMM)
1572
+ assert_no_problems(problems)
1573
+ assert_model_simple(env, :with_nums)
1574
+ end
1575
+
1576
+ #
1577
+ # conflicts with builtins
1578
+ #
1579
+
1580
+ def test_conflict_builtin
1581
+ env, problems = instantiate(%q(
1582
+ Data notTheBuiltin: "for sure"
1583
+ ), TestMMData)
1584
+ assert_no_problems(problems)
1585
+ assert_equal "for sure", env.elements.first.notTheBuiltin
1586
+ end
1587
+
1588
+ def test_builtin_in_subpackage
1589
+ env, problems = instantiate(%q(
1590
+ Data notTheBuiltin: "for sure"
1591
+ ), TestMMSubpackage)
1592
+ assert_no_problems(problems)
1593
+ assert_equal "for sure", env.elements.first.notTheBuiltin
1594
+ end
1595
+
1596
+ #
1597
+ # encoding
1598
+ #
1599
+
1600
+ def test_encodings
1601
+ input = %Q(TestNode text: "iso-8859-1 AE Umlaut: \xc4")
1602
+ # force encoding to binary in order to prevent exceptions on invalid byte sequences
1603
+ # if the encoding would be utf-8, there would be an exception with the string above
1604
+ input.force_encoding("binary")
1605
+ env, problems = instantiate(input, TestMM)
1606
+ assert_no_problems(problems)
1607
+ assert_match /AE Umlaut: /, env.elements.first.text
1608
+ end
1609
+
1610
+ #
1611
+ # line breaks
1612
+ #
1613
+
1614
+ def test_linebreak
1615
+ roots = []
1616
+ env, problems = instantiate(%Q(
1617
+ TestNode sometext,
1618
+ integer: 1,
1619
+ nums: [
1620
+ 1,
1621
+ 2
1622
+ ]
1623
+ ), TestMM, :root_elements => roots, :unlabled_arguments => proc {|clazz| ["text"]})
1624
+ assert_no_problems(problems)
1625
+ node = roots.first
1626
+ assert_equal "sometext", node.text
1627
+ assert_equal 1, node.integer
1628
+ assert_equal [1,2], node.nums
1629
+ end
1630
+
1631
+ def test_linebreak_backslash
1632
+ roots = []
1633
+ env, problems = instantiate(%Q(
1634
+ TestNode \\
1635
+ sometext
1636
+ ), TestMM, :root_elements => roots, :unlabled_arguments => proc {|clazz| ["text"]})
1637
+ assert_no_problems(problems)
1638
+ node = roots.first
1639
+ assert_equal "sometext", node.text
1640
+ end
1641
+
1642
+ def test_linebreak_backslash_problems
1643
+ roots = []
1644
+ env, problems = instantiate(%Q(
1645
+ TostNode \\
1646
+ sometext
1647
+ TostNode
1648
+ ), TestMM, :root_elements => roots, :unlabled_arguments => proc {|clazz| ["text"]})
1649
+ assert_problems([
1650
+ [/unknown command/i, 2],
1651
+ [/unknown command/i, 4],
1652
+ ], problems)
1653
+ end
1654
+
1655
+ module TestMMObjectAttribute
1656
+ extend RGen::MetamodelBuilder::ModuleExtension
1657
+ class TestNode < RGen::MetamodelBuilder::MMBase
1658
+ has_many_attr 'objs', Object
1659
+ end
1660
+ end
1661
+
1662
+ def test_object_attribute
1663
+ roots = []
1664
+ env, problems = instantiate(%Q(
1665
+ TestNode objs: ["some text", -123, someSymbol, true, false, -0.097]
1666
+ ), TestMMObjectAttribute, :root_elements => roots)
1667
+ assert_no_problems(problems)
1668
+ node = roots.first
1669
+ assert_equal ['some text', -123, 'someSymbol', true, false, -0.097], node.objs
1670
+ end
1671
+
1672
+ private
1673
+
1674
+ def instantiate(text, mm, options={})
1675
+ env = RGen::Environment.new
1676
+ lang = RText::Language.new(mm.ecore, options.merge(
1677
+ :root_classes => mm.ecore.eAllClasses.select{|c|
1678
+ c.name == "TestNode" || c.name == "Data" || c.name == "TestNodeSub" || c.name == "SubNode"}))
1679
+ inst = RText::Instantiator.new(lang)
1680
+ problems = []
1681
+ inst.instantiate(text, options.merge({:env => env, :problems => problems, :root_elements => options[:root_elements]}))
1682
+ return env, problems
1683
+ end
1684
+
1685
+ def assert_no_problems(problems)
1686
+ assert problems.empty?, problems.collect{|p| "#{p.message}, line: #{p.line}"}.join("\n")
1687
+ end
1688
+
1689
+ def assert_problems(expected, problems)
1690
+ remaining = problems.dup
1691
+ probs = []
1692
+ expected.each do |e|
1693
+ if e.is_a?(Array)
1694
+ p = remaining.find{|p| p.message =~ e[0] && p.line == e[1]}
1695
+ else
1696
+ p = remaining.find{|p| p.message =~ e}
1697
+ end
1698
+ probs << "expected problem not present: #{e}" if !p
1699
+ # make sure to not delete duplicate problems at once
1700
+ idx = remaining.index(p)
1701
+ remaining.delete_at(idx) if idx
1702
+ end
1703
+ remaining.each do |p|
1704
+ probs << "unexpected problem: #{p.message}, line: #{p.line}"
1705
+ end
1706
+ assert probs.empty?, probs.join("\n")
1707
+ end
1708
+
1709
+ def assert_model_simple(env, *opts)
1710
+ raise "unknown options" unless (opts - [:with_nums]).empty?
1711
+ root = env.find(:class => TestMM::TestNode, :text => "some text").first
1712
+ assert root != nil
1713
+ assert_equal 2, root.childs.size
1714
+ assert_equal [TestMM::TestNode, TestMM::TestNode], root.childs.collect{|c| c.class}
1715
+ assert_equal ["child", "child2"], root.childs.text
1716
+ if opts.include?(:with_nums)
1717
+ assert_equal [1, 2], root.nums
1718
+ end
1719
+ end
1720
+
1721
+ def rgen_with_bigdecimal?
1722
+ begin
1723
+ TestMM::TestNode.new.float = BigDecimal.new("0.0")
1724
+ rescue StandardError
1725
+ return false
1726
+ end
1727
+ true
1728
+ end
1729
+
1730
+ end
1731
+
1732
+