rtext 0.8.0 → 0.9.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (25) hide show
  1. checksums.yaml +5 -5
  2. data/CHANGELOG +102 -84
  3. data/RText_Protocol +46 -3
  4. data/Rakefile +46 -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/context.rb +12 -12
  9. data/lib/rtext/language.rb +5 -5
  10. data/lib/rtext/serializer.rb +1 -1
  11. data/lib/rtext/service.rb +264 -253
  12. data/lib/rtext/tokenizer.rb +1 -1
  13. data/test/completer_test.rb +606 -606
  14. data/test/context_builder_test.rb +948 -948
  15. data/test/frontend/context_test.rb +301 -205
  16. data/test/instantiator_test.rb +1732 -1691
  17. data/test/integration/frontend.log +401 -36030
  18. data/test/integration/model/test_metamodel3.ect4 +7 -0
  19. data/test/integration/test.rb +967 -918
  20. data/test/link_detector_test.rb +287 -287
  21. data/test/message_helper_test.rb +116 -118
  22. data/test/serializer_test.rb +1023 -1004
  23. data/test/tokenizer_test.rb +173 -173
  24. metadata +18 -19
  25. data/test/integration/backend.out +0 -13
data/test/integration/test.rb CHANGED
@@ -1,918 +1,967 @@
1
- # encoding: binary
2
- $:.unshift(File.dirname(__FILE__)+"/../../lib")
3
- require 'test/unit'
4
- require 'rtext/frontend/connector_manager'
5
- require 'rtext/frontend/context'
6
- require 'logger'
7
-
8
- class IntegrationTest < Test::Unit::TestCase
9
-
10
- ModelFile = File.dirname(__FILE__)+"/model/test_metamodel.ect"
11
- ModelFile2 = File.dirname(__FILE__)+"/model/test_metamodel2.ect"
12
- LargeWithErrorsFile = File.dirname(__FILE__)+"/model/test_large_with_errors.ect3"
13
- InvalidEncodingFile = File.dirname(__FILE__)+"/model/invalid_encoding.invenc"
14
- NotInRTextFile = File.dirname(__FILE__)+"/model/test.not_in_rtext"
15
- InvalidCmdLineFile = File.dirname(__FILE__)+"/model/test.invalid_cmd_line"
16
- CrashingBackendFile = File.dirname(__FILE__)+"/model/test.crashing_backend"
17
- DontOpenSocketFile = File.dirname(__FILE__)+"/model/test.dont_open_socket"
18
- CrashOnRequestFile = File.dirname(__FILE__)+"/model/test.crash_on_request"
19
-
20
- def setup_connector(file)
21
- @infile = file
22
- outfile = File.dirname(__FILE__)+"/backend.out"
23
- logfile = File.dirname(__FILE__)+"/frontend.log"
24
- logger = Logger.new(logfile)
25
- File.unlink(outfile) if File.exist?(outfile)
26
- @connection_timeout = false
27
- man = RText::Frontend::ConnectorManager.new(
28
- :logger => logger,
29
- :keep_outfile => true,
30
- :connection_timeout => 1,
31
- :outfile_provider => lambda { File.expand_path(outfile) },
32
- :connect_callback => lambda do |connector, state|
33
- @connection_timeout = true if state == :timeout
34
- end)
35
- @con = man.connector_for_file(@infile)
36
- end
37
-
38
- def teardown
39
- @con.stop if @con
40
- end
41
-
42
- def test_non_existing_file
43
- setup_connector("this is not a file")
44
- assert_nil @con
45
- end
46
-
47
- def test_not_in_rtext_file
48
- setup_connector(NotInRTextFile)
49
- assert_nil @con
50
- end
51
-
52
- def test_invalid_command_line
53
- setup_connector(InvalidCmdLineFile)
54
- assert @con
55
- response = load_model
56
- assert @connection_timeout
57
- end
58
-
59
- def test_crashing_backend
60
- setup_connector(CrashingBackendFile)
61
- assert @con
62
- response = load_model
63
- assert @connection_timeout
64
- end
65
-
66
- def test_backend_doesnt_open_socket
67
- setup_connector(DontOpenSocketFile)
68
- assert @con
69
- response = load_model
70
- assert @connection_timeout
71
- end
72
-
73
- def test_backend_crash_on_request
74
- setup_connector(CrashOnRequestFile)
75
- assert @con
76
- response = load_model
77
- assert_equal [], response["problems"]
78
- response = @con.execute_command({"command" => "link_targets", "context" => [], "column" => 1})
79
- assert_equal :timeout, response
80
- end
81
-
82
- # simulate external encoding utf-8 (-E in .rext) containing a iso-8859-1 character
83
- def test_invalid_encoding
84
- setup_connector(InvalidEncodingFile)
85
- response = load_model
86
- assert_equal "response", response["type"]
87
- assert_equal [], response["problems"]
88
- text = %Q(EPackage "iso-8859-1 umlaut: \xe4",| nsPrefix: "")
89
- context = build_context(text)
90
- assert_completions context, [
91
- "nsPrefix:",
92
- "nsURI:"
93
- ]
94
- end
95
-
96
- def test_loadmodel
97
- setup_connector(ModelFile)
98
- response = load_model
99
- assert_equal "response", response["type"]
100
- assert_equal [], response["problems"]
101
- end
102
-
103
- def test_loadmodel_large_with_errors
104
- setup_connector(LargeWithErrorsFile)
105
- response = load_model
106
- assert_equal "response", response["type"]
107
- assert_equal 43523, response["problems"].first["problems"].size
108
- end
109
-
110
- def test_unknown_command
111
- setup_connector(ModelFile)
112
- response = load_model
113
- response = @con.execute_command({"command" => "unknown"})
114
- assert_equal "unknown_command_error", response["type"]
115
- end
116
-
117
- #TODO: connector restart when .rtext file changes
118
-
119
- def test_complete_first_line
120
- setup_connector(ModelFile)
121
- load_model
122
- context = build_context <<-END
123
- |EPackage StatemachineMM {
124
- END
125
- assert_completions context, [
126
- "EPackage"
127
- ]
128
- context = build_context <<-END
129
- EPackage| StatemachineMM {
130
- END
131
- assert_completions context, [
132
- "EPackage"
133
- ]
134
- context = build_context <<-END
135
- EPackage |StatemachineMM {
136
- END
137
- assert_completions context, [
138
- "name",
139
- "nsPrefix:",
140
- "nsURI:"
141
- ]
142
- context = build_context <<-END
143
- EPackage S|tatemachineMM {
144
- END
145
- assert_completions context, [
146
- "name",
147
- "nsPrefix:",
148
- "nsURI:"
149
- ]
150
- context = build_context <<-END
151
- EPackage StatemachineMM| {
152
- END
153
- assert_completions context, [
154
- "name",
155
- "nsPrefix:",
156
- "nsURI:"
157
- ]
158
- context = build_context <<-END
159
- EPackage StatemachineMM |{
160
- END
161
- assert_completions context, [
162
- ]
163
- context = build_context <<-END
164
- EPackage StatemachineMM {|
165
- END
166
- # these columns don't exist
167
- assert_completions context, []
168
- context = build_context({:col => 27}, "EPackage StatemachineMM {")
169
- assert_completions context, []
170
- context = build_context({:col => 28}, "EPackage StatemachineMM {")
171
- assert_completions context, []
172
- context = build_context({:col => 100}, "EPackage StatemachineMM {")
173
- assert_completions context, []
174
- # before first column is like first column
175
- context = build_context({:col => 0}, "EPackage StatemachineMM {")
176
- assert_completions context, [
177
- "EPackage"
178
- ]
179
- context = build_context({:col => -1}, "EPackage StatemachineMM {")
180
- assert_completions context, [
181
- "EPackage"
182
- ]
183
- context = build_context({:col => -100}, "EPackage StatemachineMM {")
184
- assert_completions context, [
185
- "EPackage"
186
- ]
187
- end
188
-
189
- def test_nested_command
190
- setup_connector(ModelFile)
191
- load_model
192
- context = build_context <<-END
193
- EPackage StatemachineMM {
194
- | EClass State, abstract: true {
195
- END
196
- assert_completions context, [
197
- "EAnnotation",
198
- "EClass",
199
- "EClassifier",
200
- "EDataType",
201
- "EEnum",
202
- "EGenericType",
203
- "EPackage"
204
- ]
205
- context = build_context <<-END
206
- EPackage StatemachineMM {
207
- |EClass State, abstract: true {
208
- END
209
- assert_completions context, [
210
- "EAnnotation",
211
- "EClass",
212
- "EClassifier",
213
- "EDataType",
214
- "EEnum",
215
- "EGenericType",
216
- "EPackage"
217
- ]
218
- context = build_context <<-END
219
- EPackage StatemachineMM {
220
- EC|lass State, abstract: true {
221
- END
222
- assert_completions context, [
223
- "EAnnotation",
224
- "EClass",
225
- "EClassifier",
226
- "EDataType",
227
- "EEnum",
228
- "EGenericType",
229
- "EPackage"
230
- ]
231
- context = build_context <<-END
232
- EPackage StatemachineMM {
233
- EClass| State, abstract: true {
234
- END
235
- assert_completions context, [
236
- "EAnnotation",
237
- "EClass",
238
- "EClassifier",
239
- "EDataType",
240
- "EEnum",
241
- "EGenericType",
242
- "EPackage"
243
- ]
244
- context = build_context <<-END
245
- EPackage StatemachineMM {
246
- EClass |State, abstract: true {
247
- END
248
- assert_completions context, [
249
- "name",
250
- "abstract:",
251
- "interface:",
252
- "eSuperTypes:",
253
- "instanceClassName:"
254
- ]
255
- context = build_context <<-END
256
- EPackage StatemachineMM {
257
- EClass S|tate, abstract: true {
258
- END
259
- assert_completions context, [
260
- "name",
261
- "abstract:",
262
- "interface:",
263
- "eSuperTypes:",
264
- "instanceClassName:"
265
- ]
266
- context = build_context <<-END
267
- EPackage StatemachineMM {
268
- EClass State|, abstract: true {
269
- END
270
- assert_completions context, [
271
- "name",
272
- "abstract:",
273
- "interface:",
274
- "eSuperTypes:",
275
- "instanceClassName:"
276
- ]
277
- context = build_context <<-END
278
- EPackage StatemachineMM {
279
- EClass State,| abstract: true {
280
- END
281
- assert_completions context, [
282
- "abstract:",
283
- "interface:",
284
- "eSuperTypes:",
285
- "instanceClassName:"
286
- ]
287
- context = build_context <<-END
288
- EPackage StatemachineMM {
289
- EClass State, |abstract: true {
290
- END
291
- assert_completions context, [
292
- "abstract:",
293
- "interface:",
294
- "eSuperTypes:",
295
- "instanceClassName:"
296
- ]
297
- context = build_context <<-END
298
- EPackage StatemachineMM {
299
- EClass State, a|bstract: true {
300
- END
301
- assert_completions context, [
302
- "abstract:",
303
- "interface:",
304
- "eSuperTypes:",
305
- "instanceClassName:"
306
- ]
307
- context = build_context <<-END
308
- EPackage StatemachineMM {
309
- EClass State, abstract:| true {
310
- END
311
- assert_completions context, [
312
- "true",
313
- "false"
314
- ]
315
- context = build_context <<-END
316
- EPackage StatemachineMM {
317
- EClass State, abstract: |true {
318
- END
319
- assert_completions context, [
320
- "true",
321
- "false"
322
- ]
323
- context = build_context <<-END
324
- EPackage StatemachineMM {
325
- EClass State, abstract: t|rue {
326
- END
327
- assert_completions context, [
328
- "true",
329
- "false"
330
- ]
331
- context = build_context <<-END
332
- EPackage StatemachineMM {
333
- EClass State, abstract: true| {
334
- END
335
- assert_completions context, [
336
- "true",
337
- "false"
338
- ]
339
- context = build_context <<-END
340
- EPackage StatemachineMM {
341
- EClass State, abstract: true |{
342
- END
343
- assert_completions context, [
344
- ]
345
- context = build_context <<-END
346
- EPackage StatemachineMM {
347
- EClass State, abstract: true {|
348
- END
349
- assert_completions context, [
350
- ]
351
- end
352
-
353
- def test_complete_feature_after_linebreak
354
- setup_connector(ModelFile)
355
- load_model
356
- context = build_context <<-END
357
- EPackage StatemachineMM {
358
- EClass State, abstract: true {
359
- EAttribute name, eType: /StatemachineMM/StringType
360
- EReference parent,
361
- |eType: /StatemachineMM/CompositeState,
362
- END
363
- assert_completions context, [
364
- "containment:",
365
- "resolveProxies:",
366
- "eOpposite:",
367
- "changeable:",
368
- "defaultValueLiteral:",
369
- "derived:",
370
- "transient:",
371
- "unsettable:",
372
- "volatile:",
373
- "lowerBound:",
374
- "ordered:",
375
- "unique:",
376
- "upperBound:",
377
- "eType:"
378
- ]
379
- end
380
-
381
- def test_complete_reference_after_linebreak
382
- setup_connector(ModelFile)
383
- load_model
384
- context = build_context <<-END
385
- EPackage StatemachineMM {
386
- EClass State, abstract: true {
387
- EAttribute name, eType: /StatemachineMM/StringType
388
- EReference parent,
389
- eType: |/StatemachineMM/CompositeState,
390
- END
391
- assert_completions context, [
392
- "/StatemachineMM/CompositeState",
393
- "/StatemachineMM/SimpleState",
394
- "/StatemachineMM/State",
395
- "/StatemachineMM/StringType",
396
- "/StatemachineMM/Transition",
397
- "/StatemachineMM2/SimpleState",
398
- "/StatemachineMM2/State"
399
- ]
400
- end
401
-
402
- def test_complete_command_after_linebreak
403
- setup_connector(ModelFile)
404
- load_model
405
- context = build_context <<-END
406
- EPackage StatemachineMM {
407
- EClass State, abstract: true {
408
- EAttribute name, eType: /StatemachineMM/StringType
409
- EReference parent,
410
- eType: /StatemachineMM/CompositeState,
411
- eOpposite: /StatemachineMM/CompositeState/substates
412
- }
413
- EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
414
- EClass CompositeState,
415
- eSuperTypes: [
416
- /StatemachineMM/State
417
- ],
418
- abstract: false {
419
- |EReference substates, upperBound: -1, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
420
- END
421
- assert_completions context, [
422
- "EAnnotation",
423
- "EAttribute",
424
- "EOperation",
425
- "EReference",
426
- "EStructuralFeature"
427
- ]
428
- end
429
-
430
- def test_complete_value_after_linebreak
431
- setup_connector(ModelFile)
432
- load_model
433
- context = build_context <<-END
434
- EPackage StatemachineMM {
435
- EClass State, abstract: true {
436
- EAttribute name, eType: /StatemachineMM/StringType
437
- EReference parent,
438
- eType: /StatemachineMM/CompositeState,
439
- eOpposite: /StatemachineMM/CompositeState/substates
440
- }
441
- EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
442
- EClass CompositeState,
443
- eSuperTypes: [
444
- /StatemachineMM/State
445
- ],
446
- abstract: |false {
447
- END
448
- assert_completions context, [
449
- "true",
450
- "false"
451
- ]
452
- end
453
-
454
- def test_complete_in_array_after_linebreak
455
- setup_connector(ModelFile)
456
- load_model
457
- context = build_context <<-END
458
- EPackage StatemachineMM {
459
- EClass State, abstract: true {
460
- EAttribute name, eType: /StatemachineMM/StringType
461
- EReference parent,
462
- eType: /StatemachineMM/CompositeState,
463
- eOpposite: /StatemachineMM/CompositeState/substates
464
- }
465
- EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
466
- EClass CompositeState,
467
- eSuperTypes: [
468
- |/StatemachineMM/State
469
- END
470
- assert_completions context, [
471
- "/StatemachineMM/CompositeState",
472
- "/StatemachineMM/SimpleState",
473
- "/StatemachineMM/State",
474
- "/StatemachineMM/Transition",
475
- "/StatemachineMM2/SimpleState",
476
- "/StatemachineMM2/State"
477
- ]
478
- end
479
-
480
- def test_complete_in_array_after_linebreak2
481
- setup_connector(ModelFile)
482
- load_model
483
- context = build_context <<-END
484
- EPackage StatemachineMM {
485
- EClass State, abstract: true {
486
- EAttribute name, eType: /StatemachineMM/StringType
487
- EReference parent,
488
- eType: /StatemachineMM/CompositeState,
489
- eOpposite: /StatemachineMM/CompositeState/substates
490
- }
491
- EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
492
- EClass CompositeState,
493
- eSuperTypes: [
494
- /StatemachineMM/State
495
- |],
496
- END
497
- assert_completions context, [
498
- "/StatemachineMM/CompositeState",
499
- "/StatemachineMM/SimpleState",
500
- "/StatemachineMM/State",
501
- "/StatemachineMM/Transition",
502
- "/StatemachineMM2/SimpleState",
503
- "/StatemachineMM2/State"
504
- ]
505
- end
506
-
507
- def test_reference_completion
508
- setup_connector(ModelFile)
509
- load_model
510
- context = build_context <<-END
511
- EPackage StatemachineMM {
512
- EClass State, abstract: true {
513
- EAttribute name, eType: |/StatemachineMM/StringType
514
- END
515
- assert_completions context, [
516
- "/StatemachineMM/CompositeState",
517
- "/StatemachineMM/SimpleState",
518
- "/StatemachineMM/State",
519
- "/StatemachineMM/StringType",
520
- "/StatemachineMM/Transition",
521
- "/StatemachineMM2/SimpleState",
522
- "/StatemachineMM2/State",
523
- ]
524
- context = build_context <<-END
525
- EPackage StatemachineMM {
526
- EClass State, abstract: true {
527
- EAttribute name, eType: /StatemachineMM/|StringType
528
- END
529
- assert_completions context, [
530
- "/StatemachineMM/CompositeState",
531
- "/StatemachineMM/SimpleState",
532
- "/StatemachineMM/State",
533
- "/StatemachineMM/StringType",
534
- "/StatemachineMM/Transition",
535
- "/StatemachineMM2/SimpleState",
536
- "/StatemachineMM2/State",
537
- ]
538
- context = build_context <<-END
539
- EPackage StatemachineMM {
540
- EClass State, abstract: true {
541
- EAttribute name, eType: /StatemachineMM/St|ringType
542
- END
543
- assert_completions context, [
544
- "/StatemachineMM/CompositeState",
545
- "/StatemachineMM/SimpleState",
546
- "/StatemachineMM/State",
547
- "/StatemachineMM/StringType",
548
- "/StatemachineMM/Transition",
549
- "/StatemachineMM2/SimpleState",
550
- "/StatemachineMM2/State",
551
- ]
552
- context = build_context <<-END
553
- EPackage StatemachineMM {
554
- EClass State, abstract: true {
555
- EAttribute name, eType: /StatemachineMM/StringType|
556
- END
557
- assert_completions context, [
558
- "/StatemachineMM/CompositeState",
559
- "/StatemachineMM/SimpleState",
560
- "/StatemachineMM/State",
561
- "/StatemachineMM/StringType",
562
- "/StatemachineMM/Transition",
563
- "/StatemachineMM2/SimpleState",
564
- "/StatemachineMM2/State",
565
- ]
566
- end
567
-
568
- def test_reference_completion_in_array
569
- setup_connector(ModelFile)
570
- load_model
571
- context = build_context <<-END
572
- EPackage StatemachineMM {
573
- EClass State, abstract: true {
574
- EAttribute name, eType: /StatemachineMM/StringType
575
- EReference parent,
576
- eType: /StatemachineMM/CompositeState,
577
- eOpposite: /StatemachineMM/CompositeState/substates
578
- }
579
- EClass SimpleState, eSuperTypes: [|/StatemachineMM/State]
580
- END
581
- assert_completions context, [
582
- "/StatemachineMM/CompositeState",
583
- "/StatemachineMM/SimpleState",
584
- "/StatemachineMM/State",
585
- "/StatemachineMM/Transition",
586
- "/StatemachineMM2/SimpleState",
587
- "/StatemachineMM2/State",
588
- ]
589
- context = build_context <<-END
590
- EPackage StatemachineMM {
591
- EClass State, abstract: true {
592
- EAttribute name, eType: /StatemachineMM/StringType
593
- EReference parent,
594
- eType: /StatemachineMM/CompositeState,
595
- eOpposite: /StatemachineMM/CompositeState/substates
596
- }
597
- EClass SimpleState, eSuperTypes: [/StatemachineMM/S|tate]
598
- END
599
- assert_completions context, [
600
- "/StatemachineMM/CompositeState",
601
- "/StatemachineMM/SimpleState",
602
- "/StatemachineMM/State",
603
- "/StatemachineMM/Transition",
604
- "/StatemachineMM2/SimpleState",
605
- "/StatemachineMM2/State",
606
- ]
607
- context = build_context <<-END
608
- EPackage StatemachineMM {
609
- EClass State, abstract: true {
610
- EAttribute name, eType: /StatemachineMM/StringType
611
- EReference parent,
612
- eType: /StatemachineMM/CompositeState,
613
- eOpposite: /StatemachineMM/CompositeState/substates
614
- }
615
- EClass SimpleState, eSuperTypes: [/StatemachineMM/State|]
616
- END
617
- assert_completions context, [
618
- "/StatemachineMM/CompositeState",
619
- "/StatemachineMM/SimpleState",
620
- "/StatemachineMM/State",
621
- "/StatemachineMM/Transition",
622
- "/StatemachineMM2/SimpleState",
623
- "/StatemachineMM2/State",
624
- ]
625
- context = build_context <<-END
626
- EPackage StatemachineMM {
627
- EClass State, abstract: true {
628
- EAttribute name, eType: /StatemachineMM/StringType
629
- EReference parent,
630
- eType: /StatemachineMM/CompositeState,
631
- eOpposite: /StatemachineMM/CompositeState/substates
632
- }
633
- EClass SimpleState, eSuperTypes: [/StatemachineMM/State]|
634
- END
635
- assert_completions context, [
636
- ]
637
- end
638
-
639
- def test_integer_completion
640
- setup_connector(ModelFile)
641
- load_model
642
- context = build_context <<-END
643
- EPackage StatemachineMM {
644
- EClass State, abstract: true {
645
- EAttribute name, eType: /StatemachineMM/StringType
646
- EReference parent,
647
- eType: /StatemachineMM/CompositeState,
648
- eOpposite: /StatemachineMM/CompositeState/substates
649
- }
650
- EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
651
- EClass CompositeState,
652
- eSuperTypes: [
653
- /StatemachineMM/State
654
- ],
655
- abstract: false {
656
- EReference substates, upperBound: |-1, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
657
- END
658
- assert_completions context, [
659
- "0",
660
- ]
661
- context = build_context <<-END
662
- EPackage StatemachineMM {
663
- EClass State, abstract: true {
664
- EAttribute name, eType: /StatemachineMM/StringType
665
- EReference parent,
666
- eType: /StatemachineMM/CompositeState,
667
- eOpposite: /StatemachineMM/CompositeState/substates
668
- }
669
- EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
670
- EClass CompositeState,
671
- eSuperTypes: [
672
- /StatemachineMM/State
673
- ],
674
- abstract: false {
675
- EReference substates, upperBound: -1|, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
676
- END
677
- assert_completions context, [
678
- "0",
679
- ]
680
- end
681
-
682
- def test_link_targets
683
- setup_connector(ModelFile)
684
- load_model
685
- context = build_context <<-END
686
- EPackage StatemachineMM {
687
- EClass State, abstract: true {
688
- EAttribute name, eType: /St|atemachineMM/StringType
689
- END
690
- assert_link_targets context, :begin => 29, :end => 54, :targets => [
691
- {"file"=> File.expand_path(@infile),
692
- "line"=>20,
693
- "display"=>"/StatemachineMM/StringType [EDataType]"}
694
- ]
695
- context = build_context <<-END
696
- EPackage StatemachineMM {
697
- EClass State, abstract: true {
698
- EAttribute name, eType: |/StatemachineMM/StringType
699
- END
700
- assert_link_targets context, :begin => 29, :end => 54, :targets => [
701
- {"file"=> File.expand_path(@infile),
702
- "line"=>20,
703
- "display"=>"/StatemachineMM/StringType [EDataType]"}
704
- ]
705
- context = build_context <<-END
706
- EPackage StatemachineMM {
707
- EClass State, abstract: true {
708
- EAttribute name, eType: /StatemachineMM/StringTyp|e
709
- END
710
- assert_link_targets context, :begin => 29, :end => 54, :targets => [
711
- {"file"=> File.expand_path(@infile),
712
- "line"=>20,
713
- "display"=>"/StatemachineMM/StringType [EDataType]"}
714
- ]
715
- context = build_context <<-END
716
- EPackage StatemachineMM {
717
- EClass State, abstract: true {
718
- EAttribute name, eType: /StatemachineMM/StringType|
719
- END
720
- assert_link_targets context, :begin => nil, :end => nil, :targets => []
721
- context = build_context <<-END
722
- EPackage StatemachineMM {
723
- EClass State, abstract: true {
724
- EAttribute name, eType:| /StatemachineMM/StringType
725
- END
726
- assert_link_targets context, :begin => nil, :end => nil, :targets => []
727
- # backward ref
728
- context = build_context <<-END
729
- EPackage StatemachineMM {
730
- E|Class State, abstract: true {
731
- END
732
- assert_link_targets context, :begin => 3, :end => 8, :targets => [
733
- {"file"=> File.expand_path(@infile),
734
- "line"=>8,
735
- "display"=>"/StatemachineMM/SimpleState [EClass]"},
736
- {"file"=> File.expand_path(@infile),
737
- "line"=>9,
738
- "display"=>"/StatemachineMM/CompositeState [EClass]"}
739
- ]
740
- context = build_context <<-END
741
- EPackage StatemachineMM {
742
- EClass State, abstract: true {
743
- EAttribute name, eType: /StatemachineMM/StringType
744
- EReference parent,
745
- eType: /StatemachineMM/CompositeState,
746
- eOpposite: /StatemachineMM/CompositeState/substates
747
- }
748
- |EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
749
- END
750
- assert_link_targets context, :begin => 3, :end => 8, :targets => []
751
- # bad location
752
- context = build_context <<-END
753
- EPackage S|tatemachineMM {
754
- END
755
- assert_link_targets context, :begin => 10, :end => 23, :targets => []
756
- end
757
-
758
- def test_link_targets_no_text_after_name
759
- setup_connector(ModelFile)
760
- load_model
761
- context = build_context({:infile => ModelFile2}, <<-END
762
- EPackage StatemachineMM2 {
763
- ECl|ass State
764
- END
765
- )
766
- assert_link_targets context, :file => ModelFile2, :begin => 3, :end => 8, :targets => [
767
- {"file"=> File.expand_path(ModelFile2),
768
- "line"=>3,
769
- "display"=>"/StatemachineMM2/SimpleState [EClass]"}
770
- ]
771
- end
772
-
773
- def test_link_targets_after_linebreak
774
- setup_connector(ModelFile)
775
- load_model
776
- context = build_context <<-END
777
- EPackage StatemachineMM {
778
- EClass State, abstract: true {
779
- EAttribute name, eType: /StatemachineMM/StringType
780
- EReference parent,
781
- eType: /St|atemachineMM/CompositeState,
782
- END
783
- # in case of linebreaks, the begin and end column refer to the string which
784
- # was passed to the backend as the context; in this case the context extractor
785
- # appends each broken line to the previous line with all the leading whitespace removed
786
- assert_link_targets context, :begin => 30, :end => 59, :targets => [
787
- {"file"=> File.expand_path(@infile),
788
- "line"=>9,
789
- "display"=>"/StatemachineMM/CompositeState [EClass]"}
790
- ]
791
- context = build_context <<-END
792
- EPackage StatemachineMM {
793
- EClass State, abstract: true {
794
- EAttribute name, eType: /StatemachineMM/StringType
795
- EReference parent,
796
- eType: |/StatemachineMM/CompositeState,
797
- END
798
- assert_link_targets context, :begin => 30, :end => 59, :targets => [
799
- {"file"=> File.expand_path(@infile),
800
- "line"=>9,
801
- "display"=>"/StatemachineMM/CompositeState [EClass]"}
802
- ]
803
- context = build_context <<-END
804
- EPackage StatemachineMM {
805
- EClass State, abstract: true {
806
- EAttribute name, eType: /StatemachineMM/StringType
807
- EReference parent,
808
- eType: /StatemachineMM/CompositeStat|e,
809
- END
810
- assert_link_targets context, :begin => 30, :end => 59, :targets => [
811
- {"file"=> File.expand_path(@infile),
812
- "line"=>9,
813
- "display"=>"/StatemachineMM/CompositeState [EClass]"}
814
- ]
815
- context = build_context <<-END
816
- EPackage StatemachineMM {
817
- EClass State, abstract: true {
818
- EAttribute name, eType: /StatemachineMM/StringType
819
- EReference parent,
820
- eType: /StatemachineMM/CompositeState|,
821
- END
822
- assert_link_targets context, :begin => nil, :end => nil, :targets => []
823
- end
824
-
825
- def test_find_elements
826
- setup_connector(ModelFile)
827
- load_model
828
- response = @con.execute_command(
829
- {"command" => "find_elements", "search_pattern" => "Sta"})
830
- assert_equal \
831
- [{"display"=>"State [EClass] - /StatemachineMM",
832
- "file"=> File.expand_path(@infile),
833
- "line"=>2},
834
- {"display"=>"State [EClass] - /StatemachineMM2",
835
- "file"=> File.expand_path(ModelFile2),
836
- "line"=>2},
837
- {"display"=>"StatemachineMM [EPackage] - /StatemachineMM",
838
- "file"=> File.expand_path(@infile),
839
- "line"=>1},
840
- {"display"=>"StatemachineMM2 [EPackage] - /StatemachineMM2",
841
- "file"=> File.expand_path(ModelFile2),
842
- "line"=>1}], response["elements"]
843
- response = @con.execute_command(
844
- {"command" => "find_elements", "search_pattern" => "target"})
845
- assert_equal \
846
- [{"display"=>"target [EReference] - /StatemachineMM/Transition",
847
- "file"=> File.expand_path(@infile),
848
- "line"=>17}], response["elements"]
849
- response = @con.execute_command(
850
- {"command" => "find_elements", "search_pattern" => ""})
851
- assert_equal [], response["elements"]
852
- response = @con.execute_command(
853
- {"command" => "find_elements", "search_pattern" => "xxx"})
854
- assert_equal [], response["elements"]
855
- end
856
-
857
- TestContext = Struct.new(:line, :col)
858
-
859
- def build_context(text, text2=nil)
860
- if text.is_a?(Hash)
861
- context_lines = text2.split("\n")
862
- pos_in_line = text[:col] || context_lines.last.index("|") + 1
863
- infile = text[:infile] || @infile
864
- else
865
- context_lines = text.split("\n")
866
- pos_in_line = context_lines.last.index("|") + 1
867
- infile = @infile
868
- end
869
- context_lines.last.sub!("|", "")
870
-
871
- # check that the context data actally matches the real file in the filesystem
872
- content = File.open(infile, "rb"){|f| f.read}
873
- ref_lines = content.split(/\r?\n/)[0..context_lines.size-1]
874
- raise "inconsistent test data, expected\n:#{ref_lines.join("\n")}\ngot:\n#{context_lines.join("\n")}\n" \
875
- unless ref_lines == context_lines
876
-
877
- # column numbers start at 1
878
- TestContext.new(context_lines.size, pos_in_line)
879
- end
880
-
881
- def assert_link_targets(context, options)
882
- infile = options[:file] || @infile
883
- content = File.open(infile, "rb") {|f| f.read}
884
- lines = content.split(/\r?\n/)[0..context.line-1]
885
- lines, col = RText::Frontend::Context.new.extract(lines, context.col)
886
- response = @con.execute_command(
887
- {"command" => "link_targets", "context" => lines, "column" => col})
888
- assert_equal "response", response["type"]
889
- assert_equal options[:targets], response["targets"]
890
- assert_equal options[:begin], response["begin_column"]
891
- assert_equal options[:end], response["end_column"]
892
- end
893
-
894
- def assert_completions(context, expected)
895
- content = File.open(@infile, "rb"){|f| f.read}
896
- lines = content.split(/\r?\n/)[0..context.line-1]
897
- lines, col = RText::Frontend::Context.new.extract(lines, context.col)
898
- response = @con.execute_command(
899
- {"command" => "content_complete", "context" => lines, "column" => col})
900
- assert_equal expected, response["options"].collect{|o| o["insert"]}
901
- end
902
-
903
- def load_model
904
- done = false
905
- response = nil
906
- while !done
907
- response = @con.execute_command({"command" => "load_model"})
908
- if response == :connecting && !@connection_timeout
909
- sleep(0.1)
910
- @con.resume
911
- else
912
- done = true
913
- end
914
- end
915
- response
916
- end
917
-
918
- end
1
+ # encoding: binary
2
+ $:.unshift(File.dirname(__FILE__)+"/../../lib")
3
+
4
+ require 'minitest/autorun'
5
+ require 'rtext/frontend/connector_manager'
6
+ require 'rtext/frontend/context'
7
+ require 'logger'
8
+
9
+ class IntegrationTest < MiniTest::Test
10
+
11
+ ModelFile = File.dirname(__FILE__)+"/model/test_metamodel.ect"
12
+ ModelFile2 = File.dirname(__FILE__)+"/model/test_metamodel2.ect"
13
+ ModelFile3 = File.dirname(__FILE__)+"/model/test_metamodel3.ect4"
14
+ LargeWithErrorsFile = File.dirname(__FILE__)+"/model/test_large_with_errors.ect3"
15
+ InvalidEncodingFile = File.dirname(__FILE__)+"/model/invalid_encoding.invenc"
16
+ NotInRTextFile = File.dirname(__FILE__)+"/model/test.not_in_rtext"
17
+ InvalidCmdLineFile = File.dirname(__FILE__)+"/model/test.invalid_cmd_line"
18
+ CrashingBackendFile = File.dirname(__FILE__)+"/model/test.crashing_backend"
19
+ DontOpenSocketFile = File.dirname(__FILE__)+"/model/test.dont_open_socket"
20
+ CrashOnRequestFile = File.dirname(__FILE__)+"/model/test.crash_on_request"
21
+
22
+ def setup_connector(file)
23
+ @infile = file
24
+ outfile = File.dirname(__FILE__)+"/backend.out"
25
+ logfile = File.dirname(__FILE__)+"/frontend.log"
26
+ logger = Logger.new(logfile)
27
+ File.unlink(outfile) if File.exist?(outfile)
28
+ @connection_timeout = false
29
+ man = RText::Frontend::ConnectorManager.new(
30
+ :logger => logger,
31
+ :keep_outfile => true,
32
+ :connection_timeout => 2,
33
+ :outfile_provider => lambda { File.expand_path(outfile) },
34
+ :connect_callback => lambda do |connector, state|
35
+ @connection_timeout = true if state == :timeout
36
+ end)
37
+ @con = man.connector_for_file(@infile)
38
+ end
39
+
40
+ def teardown
41
+ @con.stop if @con
42
+ end
43
+
44
+ def test_non_existing_file
45
+ setup_connector("this is not a file")
46
+ assert_nil @con
47
+ end
48
+
49
+ def test_not_in_rtext_file
50
+ setup_connector(NotInRTextFile)
51
+ assert_nil @con
52
+ end
53
+
54
+ def test_invalid_command_line
55
+ setup_connector(InvalidCmdLineFile)
56
+ assert @con
57
+ response = load_model
58
+ assert @connection_timeout
59
+ end
60
+
61
+ def test_crashing_backend
62
+ setup_connector(CrashingBackendFile)
63
+ assert @con
64
+ response = load_model
65
+ assert @connection_timeout
66
+ end
67
+
68
+ def test_backend_doesnt_open_socket
69
+ setup_connector(DontOpenSocketFile)
70
+ assert @con
71
+ response = load_model
72
+ assert @connection_timeout
73
+ end
74
+
75
+ def test_backend_crash_on_request
76
+ setup_connector(CrashOnRequestFile)
77
+ assert @con
78
+ response = load_model
79
+ assert_equal [], response["problems"]
80
+ response = @con.execute_command({"command" => "link_targets", "context" => [], "column" => 1})
81
+ assert_equal :timeout, response
82
+ end
83
+
84
+ # simulate external encoding utf-8 (-E in .rext) containing a iso-8859-1 character
85
+ def test_invalid_encoding
86
+ setup_connector(InvalidEncodingFile)
87
+ response = load_model
88
+ assert_equal "response", response["type"]
89
+ assert_equal [], response["problems"]
90
+ text = %Q(EPackage "iso-8859-1 umlaut: \xe4",| nsPrefix: "")
91
+ context = build_context(text)
92
+ assert_completions context, [
93
+ "nsPrefix:",
94
+ "nsURI:"
95
+ ]
96
+ end
97
+
98
+ def test_loadmodel
99
+ setup_connector(ModelFile)
100
+ response = load_model
101
+ assert_equal "response", response["type"]
102
+ assert_equal [], response["problems"]
103
+ end
104
+
105
+ def test_loadmodel_large_with_errors
106
+ setup_connector(LargeWithErrorsFile)
107
+ response = load_model
108
+ assert_equal "response", response["type"]
109
+ assert_equal 43523, response["problems"].first["problems"].size
110
+ end
111
+
112
+ def test_unknown_command
113
+ setup_connector(ModelFile)
114
+ response = load_model
115
+ response = @con.execute_command({"command" => "unknown"})
116
+ assert_equal "unknown_command_error", response["type"]
117
+ end
118
+
119
+ #TODO: connector restart when .rtext file changes
120
+
121
+ def test_complete_first_line
122
+ setup_connector(ModelFile)
123
+ load_model
124
+ context = build_context <<-END
125
+ |EPackage StatemachineMM {
126
+ END
127
+ assert_completions context, [
128
+ "EPackage"
129
+ ]
130
+ context = build_context <<-END
131
+ EPackage| StatemachineMM {
132
+ END
133
+ assert_completions context, [
134
+ "EPackage"
135
+ ]
136
+ context = build_context <<-END
137
+ EPackage |StatemachineMM {
138
+ END
139
+ assert_completions context, [
140
+ "name",
141
+ "nsPrefix:",
142
+ "nsURI:"
143
+ ]
144
+ context = build_context <<-END
145
+ EPackage S|tatemachineMM {
146
+ END
147
+ assert_completions context, [
148
+ "name",
149
+ "nsPrefix:",
150
+ "nsURI:"
151
+ ]
152
+ context = build_context <<-END
153
+ EPackage StatemachineMM| {
154
+ END
155
+ assert_completions context, [
156
+ "name",
157
+ "nsPrefix:",
158
+ "nsURI:"
159
+ ]
160
+ context = build_context <<-END
161
+ EPackage StatemachineMM |{
162
+ END
163
+ assert_completions context, [
164
+ ]
165
+ context = build_context <<-END
166
+ EPackage StatemachineMM {|
167
+ END
168
+ # these columns don't exist
169
+ assert_completions context, []
170
+ context = build_context({:col => 27}, "EPackage StatemachineMM {")
171
+ assert_completions context, []
172
+ context = build_context({:col => 28}, "EPackage StatemachineMM {")
173
+ assert_completions context, []
174
+ context = build_context({:col => 100}, "EPackage StatemachineMM {")
175
+ assert_completions context, []
176
+ # before first column is like first column
177
+ context = build_context({:col => 0}, "EPackage StatemachineMM {")
178
+ assert_completions context, [
179
+ "EPackage"
180
+ ]
181
+ context = build_context({:col => -1}, "EPackage StatemachineMM {")
182
+ assert_completions context, [
183
+ "EPackage"
184
+ ]
185
+ context = build_context({:col => -100}, "EPackage StatemachineMM {")
186
+ assert_completions context, [
187
+ "EPackage"
188
+ ]
189
+ end
190
+
191
+ def test_nested_command
192
+ setup_connector(ModelFile)
193
+ load_model
194
+ context = build_context <<-END
195
+ EPackage StatemachineMM {
196
+ | EClass State, abstract: true {
197
+ END
198
+ assert_completions context, [
199
+ "EAnnotation",
200
+ "EClass",
201
+ "EClassifier",
202
+ "EDataType",
203
+ "EEnum",
204
+ "EGenericType",
205
+ "EPackage"
206
+ ]
207
+ context = build_context <<-END
208
+ EPackage StatemachineMM {
209
+ |EClass State, abstract: true {
210
+ END
211
+ assert_completions context, [
212
+ "EAnnotation",
213
+ "EClass",
214
+ "EClassifier",
215
+ "EDataType",
216
+ "EEnum",
217
+ "EGenericType",
218
+ "EPackage"
219
+ ]
220
+ context = build_context <<-END
221
+ EPackage StatemachineMM {
222
+ EC|lass State, abstract: true {
223
+ END
224
+ assert_completions context, [
225
+ "EAnnotation",
226
+ "EClass",
227
+ "EClassifier",
228
+ "EDataType",
229
+ "EEnum",
230
+ "EGenericType",
231
+ "EPackage"
232
+ ]
233
+ context = build_context <<-END
234
+ EPackage StatemachineMM {
235
+ EClass| State, abstract: true {
236
+ END
237
+ assert_completions context, [
238
+ "EAnnotation",
239
+ "EClass",
240
+ "EClassifier",
241
+ "EDataType",
242
+ "EEnum",
243
+ "EGenericType",
244
+ "EPackage"
245
+ ]
246
+ context = build_context <<-END
247
+ EPackage StatemachineMM {
248
+ EClass |State, abstract: true {
249
+ END
250
+ assert_completions context, [
251
+ "name",
252
+ "abstract:",
253
+ "interface:",
254
+ "eSuperTypes:",
255
+ "instanceClassName:"
256
+ ]
257
+ context = build_context <<-END
258
+ EPackage StatemachineMM {
259
+ EClass S|tate, abstract: true {
260
+ END
261
+ assert_completions context, [
262
+ "name",
263
+ "abstract:",
264
+ "interface:",
265
+ "eSuperTypes:",
266
+ "instanceClassName:"
267
+ ]
268
+ context = build_context <<-END
269
+ EPackage StatemachineMM {
270
+ EClass State|, abstract: true {
271
+ END
272
+ assert_completions context, [
273
+ "name",
274
+ "abstract:",
275
+ "interface:",
276
+ "eSuperTypes:",
277
+ "instanceClassName:"
278
+ ]
279
+ context = build_context <<-END
280
+ EPackage StatemachineMM {
281
+ EClass State,| abstract: true {
282
+ END
283
+ assert_completions context, [
284
+ "abstract:",
285
+ "interface:",
286
+ "eSuperTypes:",
287
+ "instanceClassName:"
288
+ ]
289
+ context = build_context <<-END
290
+ EPackage StatemachineMM {
291
+ EClass State, |abstract: true {
292
+ END
293
+ assert_completions context, [
294
+ "abstract:",
295
+ "interface:",
296
+ "eSuperTypes:",
297
+ "instanceClassName:"
298
+ ]
299
+ context = build_context <<-END
300
+ EPackage StatemachineMM {
301
+ EClass State, a|bstract: true {
302
+ END
303
+ assert_completions context, [
304
+ "abstract:",
305
+ "interface:",
306
+ "eSuperTypes:",
307
+ "instanceClassName:"
308
+ ]
309
+ context = build_context <<-END
310
+ EPackage StatemachineMM {
311
+ EClass State, abstract:| true {
312
+ END
313
+ assert_completions context, [
314
+ "true",
315
+ "false"
316
+ ]
317
+ context = build_context <<-END
318
+ EPackage StatemachineMM {
319
+ EClass State, abstract: |true {
320
+ END
321
+ assert_completions context, [
322
+ "true",
323
+ "false"
324
+ ]
325
+ context = build_context <<-END
326
+ EPackage StatemachineMM {
327
+ EClass State, abstract: t|rue {
328
+ END
329
+ assert_completions context, [
330
+ "true",
331
+ "false"
332
+ ]
333
+ context = build_context <<-END
334
+ EPackage StatemachineMM {
335
+ EClass State, abstract: true| {
336
+ END
337
+ assert_completions context, [
338
+ "true",
339
+ "false"
340
+ ]
341
+ context = build_context <<-END
342
+ EPackage StatemachineMM {
343
+ EClass State, abstract: true |{
344
+ END
345
+ assert_completions context, [
346
+ ]
347
+ context = build_context <<-END
348
+ EPackage StatemachineMM {
349
+ EClass State, abstract: true {|
350
+ END
351
+ assert_completions context, [
352
+ ]
353
+ end
354
+
355
+ def test_complete_feature_after_linebreak
356
+ setup_connector(ModelFile)
357
+ load_model
358
+ context = build_context <<-END
359
+ EPackage StatemachineMM {
360
+ EClass State, abstract: true {
361
+ EAttribute name, eType: /StatemachineMM/StringType
362
+ EReference parent,
363
+ |eType: /StatemachineMM/CompositeState,
364
+ END
365
+ assert_completions context, [
366
+ "containment:",
367
+ "resolveProxies:",
368
+ "eOpposite:",
369
+ "changeable:",
370
+ "defaultValueLiteral:",
371
+ "derived:",
372
+ "transient:",
373
+ "unsettable:",
374
+ "volatile:",
375
+ "lowerBound:",
376
+ "ordered:",
377
+ "unique:",
378
+ "upperBound:",
379
+ "eType:"
380
+ ]
381
+ end
382
+
383
+ def test_complete_reference_after_linebreak
384
+ setup_connector(ModelFile)
385
+ load_model
386
+ context = build_context <<-END
387
+ EPackage StatemachineMM {
388
+ EClass State, abstract: true {
389
+ EAttribute name, eType: /StatemachineMM/StringType
390
+ EReference parent,
391
+ eType: |/StatemachineMM/CompositeState,
392
+ END
393
+ assert_completions context, [
394
+ "/StatemachineMM/CompositeState",
395
+ "/StatemachineMM/SimpleState",
396
+ "/StatemachineMM/State",
397
+ "/StatemachineMM/StringType",
398
+ "/StatemachineMM/Transition",
399
+ "/StatemachineMM2/SimpleState",
400
+ "/StatemachineMM2/State"
401
+ ]
402
+ end
403
+
404
+ def test_complete_command_after_linebreak
405
+ setup_connector(ModelFile)
406
+ load_model
407
+ context = build_context <<-END
408
+ EPackage StatemachineMM {
409
+ EClass State, abstract: true {
410
+ EAttribute name, eType: /StatemachineMM/StringType
411
+ EReference parent,
412
+ eType: /StatemachineMM/CompositeState,
413
+ eOpposite: /StatemachineMM/CompositeState/substates
414
+ }
415
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
416
+ EClass CompositeState,
417
+ eSuperTypes: [
418
+ /StatemachineMM/State
419
+ ],
420
+ abstract: false {
421
+ |EReference substates, upperBound: -1, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
422
+ END
423
+ assert_completions context, [
424
+ "EAnnotation",
425
+ "EAttribute",
426
+ "EOperation",
427
+ "EReference",
428
+ "EStructuralFeature"
429
+ ]
430
+ end
431
+
432
+ def test_complete_value_after_linebreak
433
+ setup_connector(ModelFile)
434
+ load_model
435
+ context = build_context <<-END
436
+ EPackage StatemachineMM {
437
+ EClass State, abstract: true {
438
+ EAttribute name, eType: /StatemachineMM/StringType
439
+ EReference parent,
440
+ eType: /StatemachineMM/CompositeState,
441
+ eOpposite: /StatemachineMM/CompositeState/substates
442
+ }
443
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
444
+ EClass CompositeState,
445
+ eSuperTypes: [
446
+ /StatemachineMM/State
447
+ ],
448
+ abstract: |false {
449
+ END
450
+ assert_completions context, [
451
+ "true",
452
+ "false"
453
+ ]
454
+ end
455
+
456
+ def test_complete_in_array_after_linebreak
457
+ setup_connector(ModelFile)
458
+ load_model
459
+ context = build_context <<-END
460
+ EPackage StatemachineMM {
461
+ EClass State, abstract: true {
462
+ EAttribute name, eType: /StatemachineMM/StringType
463
+ EReference parent,
464
+ eType: /StatemachineMM/CompositeState,
465
+ eOpposite: /StatemachineMM/CompositeState/substates
466
+ }
467
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
468
+ EClass CompositeState,
469
+ eSuperTypes: [
470
+ |/StatemachineMM/State
471
+ END
472
+ assert_completions context, [
473
+ "/StatemachineMM/CompositeState",
474
+ "/StatemachineMM/SimpleState",
475
+ "/StatemachineMM/State",
476
+ "/StatemachineMM/Transition",
477
+ "/StatemachineMM2/SimpleState",
478
+ "/StatemachineMM2/State"
479
+ ]
480
+ end
481
+
482
+ def test_complete_in_array_after_linebreak2
483
+ setup_connector(ModelFile)
484
+ load_model
485
+ context = build_context <<-END
486
+ EPackage StatemachineMM {
487
+ EClass State, abstract: true {
488
+ EAttribute name, eType: /StatemachineMM/StringType
489
+ EReference parent,
490
+ eType: /StatemachineMM/CompositeState,
491
+ eOpposite: /StatemachineMM/CompositeState/substates
492
+ }
493
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
494
+ EClass CompositeState,
495
+ eSuperTypes: [
496
+ /StatemachineMM/State
497
+ |],
498
+ END
499
+ assert_completions context, [
500
+ ]
501
+ end
502
+
503
+ def test_complete_after_backslash
504
+ setup_connector(ModelFile3)
505
+ load_model
506
+ context = build_context <<-END
507
+ EPackage StatemachineMM3 {
508
+ EClass State
509
+ EClass \\
510
+ |SimpleState,
511
+ END
512
+ assert_completions context, [
513
+ "name",
514
+ "abstract:",
515
+ "interface:",
516
+ "eSuperTypes:",
517
+ "instanceClassName:"
518
+ ]
519
+ end
520
+
521
+ def test_complete_after_backslash2
522
+ setup_connector(ModelFile3)
523
+ load_model
524
+ context = build_context <<-END
525
+ EPackage StatemachineMM3 {
526
+ EClass State
527
+ EClass \\
528
+ SimpleState,
529
+ |eSuperTypes: [/StatemachineMM3/State]
530
+ END
531
+ assert_completions context, [
532
+ "abstract:",
533
+ "interface:",
534
+ "eSuperTypes:",
535
+ "instanceClassName:"
536
+ ]
537
+ end
538
+
539
+ def test_link_target_after_backslash
540
+ setup_connector(ModelFile3)
541
+ load_model
542
+ context = build_context <<-END
543
+ EPackage StatemachineMM3 {
544
+ EClass State
545
+ EClass \\
546
+ SimpleState,
547
+ eSuperTypes: [/S|tatemachineMM3/State]
548
+ END
549
+ assert_link_targets context, :file => ModelFile3, :begin => 45, :end => 66, :targets => [
550
+ {"file"=> File.expand_path(ModelFile3),
551
+ "line"=>2,
552
+ "display"=>"/StatemachineMM3/State [EClass]"}
553
+ ]
554
+ end
555
+
556
+ def test_reference_completion
557
+ setup_connector(ModelFile)
558
+ load_model
559
+ context = build_context <<-END
560
+ EPackage StatemachineMM {
561
+ EClass State, abstract: true {
562
+ EAttribute name, eType: |/StatemachineMM/StringType
563
+ END
564
+ assert_completions context, [
565
+ "/StatemachineMM/CompositeState",
566
+ "/StatemachineMM/SimpleState",
567
+ "/StatemachineMM/State",
568
+ "/StatemachineMM/StringType",
569
+ "/StatemachineMM/Transition",
570
+ "/StatemachineMM2/SimpleState",
571
+ "/StatemachineMM2/State",
572
+ ]
573
+ context = build_context <<-END
574
+ EPackage StatemachineMM {
575
+ EClass State, abstract: true {
576
+ EAttribute name, eType: /StatemachineMM/|StringType
577
+ END
578
+ assert_completions context, [
579
+ "/StatemachineMM/CompositeState",
580
+ "/StatemachineMM/SimpleState",
581
+ "/StatemachineMM/State",
582
+ "/StatemachineMM/StringType",
583
+ "/StatemachineMM/Transition",
584
+ "/StatemachineMM2/SimpleState",
585
+ "/StatemachineMM2/State",
586
+ ]
587
+ context = build_context <<-END
588
+ EPackage StatemachineMM {
589
+ EClass State, abstract: true {
590
+ EAttribute name, eType: /StatemachineMM/St|ringType
591
+ END
592
+ assert_completions context, [
593
+ "/StatemachineMM/CompositeState",
594
+ "/StatemachineMM/SimpleState",
595
+ "/StatemachineMM/State",
596
+ "/StatemachineMM/StringType",
597
+ "/StatemachineMM/Transition",
598
+ "/StatemachineMM2/SimpleState",
599
+ "/StatemachineMM2/State",
600
+ ]
601
+ context = build_context <<-END
602
+ EPackage StatemachineMM {
603
+ EClass State, abstract: true {
604
+ EAttribute name, eType: /StatemachineMM/StringType|
605
+ END
606
+ assert_completions context, [
607
+ "/StatemachineMM/CompositeState",
608
+ "/StatemachineMM/SimpleState",
609
+ "/StatemachineMM/State",
610
+ "/StatemachineMM/StringType",
611
+ "/StatemachineMM/Transition",
612
+ "/StatemachineMM2/SimpleState",
613
+ "/StatemachineMM2/State",
614
+ ]
615
+ end
616
+
617
+ def test_reference_completion_in_array
618
+ setup_connector(ModelFile)
619
+ load_model
620
+ context = build_context <<-END
621
+ EPackage StatemachineMM {
622
+ EClass State, abstract: true {
623
+ EAttribute name, eType: /StatemachineMM/StringType
624
+ EReference parent,
625
+ eType: /StatemachineMM/CompositeState,
626
+ eOpposite: /StatemachineMM/CompositeState/substates
627
+ }
628
+ EClass SimpleState, eSuperTypes: [|/StatemachineMM/State]
629
+ END
630
+ assert_completions context, [
631
+ "/StatemachineMM/CompositeState",
632
+ "/StatemachineMM/SimpleState",
633
+ "/StatemachineMM/State",
634
+ "/StatemachineMM/Transition",
635
+ "/StatemachineMM2/SimpleState",
636
+ "/StatemachineMM2/State",
637
+ ]
638
+ context = build_context <<-END
639
+ EPackage StatemachineMM {
640
+ EClass State, abstract: true {
641
+ EAttribute name, eType: /StatemachineMM/StringType
642
+ EReference parent,
643
+ eType: /StatemachineMM/CompositeState,
644
+ eOpposite: /StatemachineMM/CompositeState/substates
645
+ }
646
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/S|tate]
647
+ END
648
+ assert_completions context, [
649
+ "/StatemachineMM/CompositeState",
650
+ "/StatemachineMM/SimpleState",
651
+ "/StatemachineMM/State",
652
+ "/StatemachineMM/Transition",
653
+ "/StatemachineMM2/SimpleState",
654
+ "/StatemachineMM2/State",
655
+ ]
656
+ context = build_context <<-END
657
+ EPackage StatemachineMM {
658
+ EClass State, abstract: true {
659
+ EAttribute name, eType: /StatemachineMM/StringType
660
+ EReference parent,
661
+ eType: /StatemachineMM/CompositeState,
662
+ eOpposite: /StatemachineMM/CompositeState/substates
663
+ }
664
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/State|]
665
+ END
666
+ assert_completions context, [
667
+ "/StatemachineMM/CompositeState",
668
+ "/StatemachineMM/SimpleState",
669
+ "/StatemachineMM/State",
670
+ "/StatemachineMM/Transition",
671
+ "/StatemachineMM2/SimpleState",
672
+ "/StatemachineMM2/State",
673
+ ]
674
+ context = build_context <<-END
675
+ EPackage StatemachineMM {
676
+ EClass State, abstract: true {
677
+ EAttribute name, eType: /StatemachineMM/StringType
678
+ EReference parent,
679
+ eType: /StatemachineMM/CompositeState,
680
+ eOpposite: /StatemachineMM/CompositeState/substates
681
+ }
682
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/State]|
683
+ END
684
+ assert_completions context, [
685
+ ]
686
+ end
687
+
688
+ def test_integer_completion
689
+ setup_connector(ModelFile)
690
+ load_model
691
+ context = build_context <<-END
692
+ EPackage StatemachineMM {
693
+ EClass State, abstract: true {
694
+ EAttribute name, eType: /StatemachineMM/StringType
695
+ EReference parent,
696
+ eType: /StatemachineMM/CompositeState,
697
+ eOpposite: /StatemachineMM/CompositeState/substates
698
+ }
699
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
700
+ EClass CompositeState,
701
+ eSuperTypes: [
702
+ /StatemachineMM/State
703
+ ],
704
+ abstract: false {
705
+ EReference substates, upperBound: |-1, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
706
+ END
707
+ assert_completions context, [
708
+ "1",
709
+ ]
710
+ context = build_context <<-END
711
+ EPackage StatemachineMM {
712
+ EClass State, abstract: true {
713
+ EAttribute name, eType: /StatemachineMM/StringType
714
+ EReference parent,
715
+ eType: /StatemachineMM/CompositeState,
716
+ eOpposite: /StatemachineMM/CompositeState/substates
717
+ }
718
+ EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
719
+ EClass CompositeState,
720
+ eSuperTypes: [
721
+ /StatemachineMM/State
722
+ ],
723
+ abstract: false {
724
+ EReference substates, upperBound: -1|, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
725
+ END
726
+ assert_completions context, [
727
+ "1",
728
+ ]
729
+ end
730
+
731
+ def test_link_targets
732
+ setup_connector(ModelFile)
733
+ load_model
734
+ context = build_context <<-END
735
+ EPackage StatemachineMM {
736
+ EClass State, abstract: true {
737
+ EAttribute name, eType: /St|atemachineMM/StringType
738
+ END
739
+ assert_link_targets context, :begin => 29, :end => 54, :targets => [
740
+ {"file"=> File.expand_path(@infile),
741
+ "line"=>20,
742
+ "display"=>"/StatemachineMM/StringType [EDataType]"}
743
+ ]
744
+ context = build_context <<-END
745
+ EPackage StatemachineMM {
746
+ EClass State, abstract: true {
747
+ EAttribute name, eType: |/StatemachineMM/StringType
748
+ END
749
+ assert_link_targets context, :begin => 29, :end => 54, :targets => [
750
+ {"file"=> File.expand_path(@infile),
751
+ "line"=>20,
752
+ "display"=>"/StatemachineMM/StringType [EDataType]"}
753
+ ]
754
+ context = build_context <<-END
755
+ EPackage StatemachineMM {
756
+ EClass State, abstract: true {
757
+ EAttribute name, eType: /StatemachineMM/StringTyp|e
758
+ END
759
+ assert_link_targets context, :begin => 29, :end => 54, :targets => [
760
+ {"file"=> File.expand_path(@infile),
761
+ "line"=>20,
762
+ "display"=>"/StatemachineMM/StringType [EDataType]"}
763
+ ]
764
+ context = build_context <<-END
765
+ EPackage StatemachineMM {
766
+ EClass State, abstract: true {
767
+ EAttribute name, eType: /StatemachineMM/StringType|
768
+ END
769
+ assert_link_targets context, :begin => nil, :end => nil, :targets => []
770
+ context = build_context <<-END
771
+ EPackage StatemachineMM {
772
+ EClass State, abstract: true {
773
+ EAttribute name, eType:| /StatemachineMM/StringType
774
+ END
775
+ assert_link_targets context, :begin => nil, :end => nil, :targets => []
776
+ # backward ref
777
+ context = build_context <<-END
778
+ EPackage StatemachineMM {
779
+ E|Class State, abstract: true {
780
+ END
781
+ assert_link_targets context, :begin => 3, :end => 8, :targets => [
782
+ {"file"=> File.expand_path(@infile),
783
+ "line"=>8,
784
+ "display"=>"/StatemachineMM/SimpleState [EClass]"},
785
+ {"file"=> File.expand_path(@infile),
786
+ "line"=>9,
787
+ "display"=>"/StatemachineMM/CompositeState [EClass]"}
788
+ ]
789
+ context = build_context <<-END
790
+ EPackage StatemachineMM {
791
+ EClass State, abstract: true {
792
+ EAttribute name, eType: /StatemachineMM/StringType
793
+ EReference parent,
794
+ eType: /StatemachineMM/CompositeState,
795
+ eOpposite: /StatemachineMM/CompositeState/substates
796
+ }
797
+ |EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
798
+ END
799
+ assert_link_targets context, :begin => 3, :end => 8, :targets => []
800
+ # bad location
801
+ context = build_context <<-END
802
+ EPackage S|tatemachineMM {
803
+ END
804
+ assert_link_targets context, :begin => 10, :end => 23, :targets => []
805
+ end
806
+
807
+ def test_link_targets_no_text_after_name
808
+ setup_connector(ModelFile)
809
+ load_model
810
+ context = build_context({:infile => ModelFile2}, <<-END
811
+ EPackage StatemachineMM2 {
812
+ ECl|ass State
813
+ END
814
+ )
815
+ assert_link_targets context, :file => ModelFile2, :begin => 3, :end => 8, :targets => [
816
+ {"file"=> File.expand_path(ModelFile2),
817
+ "line"=>3,
818
+ "display"=>"/StatemachineMM2/SimpleState [EClass]"}
819
+ ]
820
+ end
821
+
822
+ def test_link_targets_after_linebreak
823
+ setup_connector(ModelFile)
824
+ load_model
825
+ context = build_context <<-END
826
+ EPackage StatemachineMM {
827
+ EClass State, abstract: true {
828
+ EAttribute name, eType: /StatemachineMM/StringType
829
+ EReference parent,
830
+ eType: /St|atemachineMM/CompositeState,
831
+ END
832
+ # in case of linebreaks, the begin and end column refer to the string which
833
+ # was passed to the backend as the context; in this case the context extractor
834
+ # appends each broken line to the previous line with all the leading whitespace removed
835
+ assert_link_targets context, :begin => 37, :end => 66, :targets => [
836
+ {"file"=> File.expand_path(@infile),
837
+ "line"=>9,
838
+ "display"=>"/StatemachineMM/CompositeState [EClass]"}
839
+ ]
840
+ context = build_context <<-END
841
+ EPackage StatemachineMM {
842
+ EClass State, abstract: true {
843
+ EAttribute name, eType: /StatemachineMM/StringType
844
+ EReference parent,
845
+ eType: |/StatemachineMM/CompositeState,
846
+ END
847
+ assert_link_targets context, :begin => 37, :end => 66, :targets => [
848
+ {"file"=> File.expand_path(@infile),
849
+ "line"=>9,
850
+ "display"=>"/StatemachineMM/CompositeState [EClass]"}
851
+ ]
852
+ context = build_context <<-END
853
+ EPackage StatemachineMM {
854
+ EClass State, abstract: true {
855
+ EAttribute name, eType: /StatemachineMM/StringType
856
+ EReference parent,
857
+ eType: /StatemachineMM/CompositeStat|e,
858
+ END
859
+ assert_link_targets context, :begin => 37, :end => 66, :targets => [
860
+ {"file"=> File.expand_path(@infile),
861
+ "line"=>9,
862
+ "display"=>"/StatemachineMM/CompositeState [EClass]"}
863
+ ]
864
+ context = build_context <<-END
865
+ EPackage StatemachineMM {
866
+ EClass State, abstract: true {
867
+ EAttribute name, eType: /StatemachineMM/StringType
868
+ EReference parent,
869
+ eType: /StatemachineMM/CompositeState|,
870
+ END
871
+ assert_link_targets context, :begin => nil, :end => nil, :targets => []
872
+ end
873
+
874
+ def test_find_elements
875
+ setup_connector(ModelFile)
876
+ load_model
877
+ response = @con.execute_command(
878
+ {"command" => "find_elements", "search_pattern" => "Sta"})
879
+ assert_equal \
880
+ [{"display"=>"State [EClass] - /StatemachineMM",
881
+ "file"=> File.expand_path(@infile),
882
+ "line"=>2},
883
+ {"display"=>"State [EClass] - /StatemachineMM2",
884
+ "file"=> File.expand_path(ModelFile2),
885
+ "line"=>2},
886
+ {"display"=>"StatemachineMM [EPackage] - /StatemachineMM",
887
+ "file"=> File.expand_path(@infile),
888
+ "line"=>1},
889
+ {"display"=>"StatemachineMM2 [EPackage] - /StatemachineMM2",
890
+ "file"=> File.expand_path(ModelFile2),
891
+ "line"=>1}], response["elements"]
892
+ response = @con.execute_command(
893
+ {"command" => "find_elements", "search_pattern" => "target"})
894
+ assert_equal \
895
+ [{"display"=>"target [EReference] - /StatemachineMM/Transition",
896
+ "file"=> File.expand_path(@infile),
897
+ "line"=>17}], response["elements"]
898
+ response = @con.execute_command(
899
+ {"command" => "find_elements", "search_pattern" => ""})
900
+ assert_equal [], response["elements"]
901
+ response = @con.execute_command(
902
+ {"command" => "find_elements", "search_pattern" => "xxx"})
903
+ assert_equal [], response["elements"]
904
+ end
905
+
906
+ TestContext = Struct.new(:line, :col)
907
+
908
+ def build_context(text, text2=nil)
909
+ if text.is_a?(Hash)
910
+ context_lines = text2.split("\n")
911
+ pos_in_line = text[:col] || context_lines.last.index("|") + 1
912
+ infile = text[:infile] || @infile
913
+ else
914
+ context_lines = text.split("\n")
915
+ pos_in_line = context_lines.last.index("|") + 1
916
+ infile = @infile
917
+ end
918
+ context_lines.last.sub!("|", "")
919
+
920
+ # check that the context data actally matches the real file in the filesystem
921
+ content = File.open(infile, "rb"){|f| f.read}
922
+ ref_lines = content.split(/\r?\n/)[0..context_lines.size-1]
923
+ raise "inconsistent test data, expected\n:#{ref_lines.join("\n")}\ngot:\n#{context_lines.join("\n")}\n" \
924
+ unless ref_lines == context_lines
925
+
926
+ # column numbers start at 1
927
+ TestContext.new(context_lines.size, pos_in_line)
928
+ end
929
+
930
+ def assert_link_targets(context, options)
931
+ infile = options[:file] || @infile
932
+ content = File.open(infile, "rb") {|f| f.read}
933
+ lines = content.split(/\r?\n/)[0..context.line-1]
934
+ lines, col = RText::Frontend::Context.new.extract(lines, context.col)
935
+ response = @con.execute_command(
936
+ {"command" => "link_targets", "context" => lines, "column" => col})
937
+ assert_equal "response", response["type"]
938
+ assert_equal options[:targets], response["targets"]
939
+ assert_equal options[:begin], response["begin_column"]
940
+ assert_equal options[:end], response["end_column"]
941
+ end
942
+
943
+ def assert_completions(context, expected)
944
+ content = File.open(@infile, "rb"){|f| f.read}
945
+ lines = content.split(/\r?\n/)[0..context.line-1]
946
+ lines, col = RText::Frontend::Context.new.extract(lines, context.col)
947
+ response = @con.execute_command(
948
+ {"command" => "content_complete", "context" => lines, "column" => col})
949
+ assert_equal expected, response["options"].collect{|o| o["insert"]}
950
+ end
951
+
952
+ def load_model
953
+ done = false
954
+ response = nil
955
+ while !done
956
+ response = @con.execute_command({"command" => "load_model"})
957
+ if response == :connecting && !@connection_timeout
958
+ sleep(0.1)
959
+ @con.resume
960
+ else
961
+ done = true
962
+ end
963
+ end
964
+ response
965
+ end
966
+
967
+ end