rtext 0.8.0 → 0.9.2

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