source: branches/dev-mo-2530/Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo @ 13922

Last change on this file since 13922 was 13922, checked in by molsson, 5 weeks ago

Merged revision(s) 13898-13913 from branches/dev-mo-2617:
#5843 Moved type checking of conditional attributes so that it is always done.
........
#5843 Conditional attribute requires variability fixed parameter or less.
........
#5843 Updated error message NON_BOOLEAN_CONDITIONAL_GUARD to say Boolean instead of boolean.
........
#5843 Merged non-scalar and non-boolean conditional guard error messages.
........

File size: 95.1 KB
Line 
1/*
2    Copyright (C) 2009-2013 Modelon AB
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, version 3 of the License.
7
8    This program is distributed in the hope that it will be useful,
9    but WITHOUT ANY WARRANTY; without even the implied warranty of
10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11    GNU General Public License for more details.
12
13    You should have received a copy of the GNU General Public License
14    along with this program.  If not, see <http://www.gnu.org/licenses/>.
15*/
16
17
18package NameTests
19
20  model NameTest2
21class A
22
23 class B
24        Real x;
25       
26                class C
27                  Real y;
28                  equation
29                  y=2;
30                end C;
31
32          C c;
33
34 end B;
35 B b,b1;
36 B.C c;
37 Real y,x;
38equation
39x=-(1/1)*(1*1)-(2+1)^3+x^(-3+2);
40b.c.y+1=b.c.y;
41c.y=0;
42
43b.x=b.c.y;
44
45//c.y=1;
46
47end A;
48
49        A a;
50
51
52    annotation(__JModelica(UnitTesting(tests={
53        FlatteningTestCase(
54            name="NameTest2",
55            description="Basic test of name lookup",
56            flatModel="
57fclass NameTests.NameTest2
58 Real a.b.x;
59 Real a.b.c.y;
60 Real a.b1.x;
61 Real a.b1.c.y;
62 Real a.c.y;
63 Real a.y;
64 Real a.x;
65equation
66 a.x = -1 - (2 + 1) ^ 3 + a.x ^ (-3 + 2);
67 a.b.c.y + 1 = a.b.c.y;
68 a.c.y = 0;
69 a.b.x = a.b.c.y;
70 a.b.c.y = 2;
71 a.b1.c.y = 2;
72 a.c.y = 2;
73end NameTests.NameTest2;
74")})));
75  end NameTest2;
76
77
78
79  model NameTest3_Err
80 
81 
82A a;
83
84
85    annotation(__JModelica(UnitTesting(tests={
86        ErrorTestCase(
87            name="NameTest3_Err",
88            description="Basic test of name lookup",
89            errorMessage="
901 errors found:
91
92Error at line 4, column 1, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
93  Cannot find class declaration for A
94")})));
95  end NameTest3_Err;
96
97
98
99model NameTest4_Err
100 
101 
102  model M
103        model A
104                Real x=3;
105        end A;
106        B a;
107  end M;
108 
109  M m;
110
111
112    annotation(__JModelica(UnitTesting(tests={
113        ErrorTestCase(
114            name="NameTest4_Err",
115            description="Basic test of name lookup",
116            errorMessage="
1171 errors found:
118
119Error at line 8, column 4, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
120In component m:
121  Cannot find class declaration for B
122")})));
123  end NameTest4_Err;
124
125
126
127model NameTest5_Err
128 
129  model A
130    Real y = 4;
131  end A;
132 
133  A a;
134  Real y;
135equation
136  b.y = y + a.x;
137
138    annotation(__JModelica(UnitTesting(tests={
139        ErrorTestCase(
140            name="NameTest5_Err",
141            description="Basic test of name lookup",
142            errorMessage="
1432 errors found:
144
145Error at line 10, column 3, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
146  Cannot find class or component declaration for b
147
148Error at line 10, column 15, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
149  Cannot find class or component declaration for x
150")})));
151end NameTest5_Err;
152
153model NameTest55_Err
154 
155 
156  model A
157      Real y = 4;
158    equation
159      y = x;
160  end A;
161 
162  A a;
163
164    annotation(__JModelica(UnitTesting(tests={
165        ErrorTestCase(
166            name="NameTest55_Err",
167            description="Basic test of name lookup",
168            errorMessage="
1691 errors found:
170
171Error at line 7, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
172In component a:
173  Cannot find class or component declaration for x
174")})));
175end NameTest55_Err;
176
177
178model NameTest6_Err
179 
180 
181  model A
182    Real x = y;
183  end A;
184 
185  A a;
186
187    annotation(__JModelica(UnitTesting(tests={
188        ErrorTestCase(
189            name="NameTest6_Err",
190            description="Basic test of name lookup",
191            errorMessage="
1921 errors found:
193
194Error at line 5, column 14, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
195In component a:
196  Cannot find class or component declaration for y
197")})));
198end NameTest6_Err;
199
200model NameTest7_Err
201 
202 
203  model A
204    B x;
205  end A;
206 
207  A a1;
208  A a2;
209
210    annotation(__JModelica(UnitTesting(tests={
211        ErrorTestCase(
212            name="NameTest7_Err",
213            description="Basic test of name lookup",
214            errorMessage="
2151 errors found:
216
217Error at line 5, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
218In components:
219    a1
220    a2
221  Cannot find class declaration for B
222")})));
223end NameTest7_Err;
224
225model NameTest8_Err
226 
227 
228  model C = D;
229 
230  C c;
231
232    annotation(__JModelica(UnitTesting(tests={
233        ErrorTestCase(
234            name="NameTest8_Err",
235            description="Basic test of name lookup",
236            errorMessage="
2371 errors found:
238
239Error at line 4, column 13, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
240In component c:
241  Cannot find class declaration for D
242")})));
243end NameTest8_Err;
244
245model NameTest9_Err
246 
247  model A
248    Real x = 4;
249  end A;
250 
251  model B
252    Real x = 6;
253    Real y = 7;
254  end B;
255 
256  model C
257    replaceable B b constrainedby A;
258  end C;
259
260  C c(b(y=3));
261
262
263    annotation(__JModelica(UnitTesting(tests={
264        WarningTestCase(
265            name="NameTest9_Err",
266            description="Test that names are looked up in constraining clauses.",
267            errorMessage="
2681 warnings found:
269
270Warning at line 16, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NOT_IN_CONSTRAINING_TYPE:
271  Access to component y not recommended, it is not present in constraining type of declaration 'replaceable B b constrainedby A'
272")})));
273  end NameTest9_Err;
274
275model NameTest10_Err
276 
277  package P1
278  model A
279    Real x = 4;
280  end A;
281   
282  end P1;
283
284  package P2
285  model A
286    Real x = 4;
287  end A;
288 
289  model B
290    Real x = 6;
291    Real y = 7;
292  end B;
293 
294  end P2;
295
296  replaceable package P = P2 constrainedby P1;
297 
298  P.B b;
299 
300
301    annotation(__JModelica(UnitTesting(tests={
302        WarningTestCase(
303            name="NameTest10_Err",
304            description="Test that names are looked up in constraining clauses.",
305            errorMessage="
3061 warnings found:
307
308Warning at line 24, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NOT_IN_CONSTRAINING_TYPE:
309  Access to class B not recommended, it is not present in constraining type of declaration 'replaceable package P = P2 constrainedby P1'
310")})));
311  end NameTest10_Err;
312 
313  model NameTest11_Err
314 
315 model A
316        parameter Real p1 = 4;
317 end A;
318 
319 parameter Real p = 5;
320 A a(p1=p1);
321 
322
323    annotation(__JModelica(UnitTesting(tests={
324        ErrorTestCase(
325            name="NameTest11_Err",
326            description="Test that names are looked up correct.",
327            errorMessage="
3281 errors found:
329
330Error at line 8, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
331  Cannot find class or component declaration for p1
332")})));
333  end NameTest11_Err;
334 
335 
336model NameTest12_Err
337 
338model M
339
340 model A
341        Real x = 4;
342 end A;
343
344 model B
345        Real x = 4;
346        Real y = 4;
347 end B;
348 
349 replaceable A a;
350 
351end M;
352
353M m(redeclare B a);
354
355 
356
357    annotation(__JModelica(UnitTesting(tests={
358        ErrorTestCase(
359            name="NameTest12_Err",
360            description="Test that names are looked up correct.",
361            errorMessage="
3621 errors found:
363
364Error at line 18, column 15, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
365  Cannot find class declaration for B
366")})));
367end NameTest12_Err;
368 
369 
370 model NameTest13_Err
371 
372   package P
373   model A
374    Real x=1;
375   end A;
376 
377     model B
378        Real x=2;
379        Real y=3;
380     end B;
381 
382     model C
383        Real x=2;
384        Real y=3;
385        Real z=4;
386     end C;
387     
388     replaceable model BB = B(z=3);
389     
390   end P;
391 
392   package PP = P(redeclare model BB
393                              extends C(y=4);
394                            end BB);
395 
396  PP.BB bb(y=6);
397 
398
399    annotation(__JModelica(UnitTesting(tests={
400        ErrorTestCase(
401            name="NameTest13_Err",
402            description="Test that names are looked up correct.",
403            errorMessage="
4044 errors found:
405
406Error at line 19, column 31, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
407  Cannot find component declaration for z
408
409Error at line 24, column 37, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
410In component bb:
411  Cannot find class declaration for C
412
413Error at line 24, column 39, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
414In component bb:
415  Cannot find component declaration for y
416
417Error at line 27, column 12, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
418  Cannot find component declaration for y
419")})));
420end NameTest13_Err;
421 
422 model NameTest14_Err
423 
424   package P
425   model A
426    Real x=1;
427   end A;
428 
429     model B
430        Real x=2;
431        Real y=3;
432     end B;
433 
434     model C
435        Real x=2;
436        Real y=3;
437        Real z=4;
438     end C;
439     
440     
441     replaceable model BB
442         extends B(z=pBB);
443     end BB;
444           
445   end P;
446 
447   package PP = P(redeclare replaceable model BB = P.B(z=p));
448 
449   PP.BB bb(z=pp);
450 
451
452    annotation(__JModelica(UnitTesting(tests={
453        ErrorTestCase(
454            name="NameTest14_Err",
455            description="Test that names are looked up correct.",
456            errorMessage="
4573 errors found:
458
459Error at line 26, column 56, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
460  Cannot find component declaration for z
461
462Error at line 28, column 13, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
463  Cannot find component declaration for z
464
465Error at line 28, column 15, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
466  Cannot find class or component declaration for pp
467")})));
468end NameTest14_Err;
469 
470class NameTest15
471protected Real x=1;
472
473        annotation(__JModelica(UnitTesting(tests={
474                FlatteningTestCase(
475                        name="NameTest15",
476                        description="Check correct flattening of protected variable",
477                        flatModel="
478fclass NameTests.NameTest15
479protected
480 Real x = 1;
481
482end NameTests.NameTest15;
483")})));
484end NameTest15;
485
486
487class NameTest16
488constant Real c = 1.0;
489parameter Real p = c;
490
491
492        annotation(__JModelica(UnitTesting(tests={
493                FlatteningTestCase(
494                        name="NameTest16",
495                        description="Check that constants are inlined.",
496                        flatModel="
497fclass NameTests.NameTest16
498constant Real c = 1.0;
499parameter Real p = 1.0;
500
501end NameTests.NameTest16;
502")})));
503end NameTest16;
504
505model NameTest17
506  Real x(fixed,start);
507equation
508  x=2;
509
510    annotation(__JModelica(UnitTesting(tests={
511        FlatteningTestCase(
512            name="NameTest17",
513            description="Check that modifiers without binding expressions are accepted.",
514            flatModel="
515fclass NameTests.NameTest17
516 Real x;
517equation
518 x = 2;
519end NameTests.NameTest17;
520")})));
521end NameTest17;
522
523
524model NameTest18
525        package A
526                package C
527                        model M
528                                Real x;
529                        end M;
530                end C;
531               
532                package D
533                        extends C;
534                end D;
535        end A;
536       
537        package B
538                model M
539                        Real x;
540                end M;
541        end B;
542       
543        package E
544                replaceable package F = B constrainedby A.D;
545        end E;
546       
547        E.F.M y;
548
549    annotation(__JModelica(UnitTesting(tests={
550        FlatteningTestCase(
551            name="NameTest18",
552            description="Constraining class extending local class",
553            flatModel="
554fclass NameTests.NameTest18
555 Real y.x;
556end NameTests.NameTest18;
557")})));
558end NameTest18;
559
560
561model NameTest19
562    package A
563        constant Integer b = 1;
564    end A;
565   
566    model B
567        Real x[1];
568    end B;
569   
570    B y;
571equation
572    y.x[A.b] = 1;
573
574    annotation(__JModelica(UnitTesting(tests={
575        FlatteningTestCase(
576            name="NameTest19",
577            description="Lookup of classes from array subscripts of dotted access",
578            flatModel="
579fclass NameTests.NameTest19
580 Real y.x[1];
581equation
582 y.x[1] = 1;
583end NameTests.NameTest19;
584")})));
585end NameTest19;
586
587
588model NameTest20
589        package A
590                function f
591                        output Real z;
592                algorithm
593                        z := 1;
594                end f;
595               
596                model B
597                        Real x;
598                equation
599                        x = f();
600                end B;
601        end A;
602       
603        model C
604                extends A.B;
605        end C;
606       
607        C y;
608
609    annotation(__JModelica(UnitTesting(tests={
610        FlatteningTestCase(
611            name="NameTest20",
612            description="Extending class with call to function in surrounding class",
613            flatModel="
614fclass NameTests.NameTest20
615 Real y.x;
616equation
617 y.x = NameTests.NameTest20.A.f();
618
619public
620 function NameTests.NameTest20.A.f
621  output Real z;
622 algorithm
623  z := 1;
624  return;
625 end NameTests.NameTest20.A.f;
626
627end NameTests.NameTest20;
628")})));
629end NameTest20;
630
631
632model NameTest21
633    model A
634        replaceable package B = C;
635       
636        J c(redeclare package I = B);
637    end A;
638   
639    package C
640        constant Real a = 1;
641    end C;
642   
643    model D
644        package E = F;
645       
646        A b(redeclare package B = E.G);
647    end D;
648   
649    package F
650        package G
651            extends C(a = 2);
652        end G;
653    end F;
654   
655    model J
656        replaceable package I = C;
657       
658        Real x = I.a;
659    end J;
660   
661    D d;
662
663    annotation(__JModelica(UnitTesting(tests={
664        FlatteningTestCase(
665            name="NameTest21",
666            description="Chain of redeclared short class declarations",
667            flatModel="
668fclass NameTests.NameTest21
669 Real d.b.c.x = 2.0;
670end NameTests.NameTest21;
671")})));
672end NameTest21;
673
674
675model NameTest22
676  model C
677   constant Real a = 1;
678  end C;
679 
680  package F
681        package G
682          extends C(a=2);
683        end G;
684  end F;
685
686  model D
687   package E = F;
688   package B = E.G(a=3);
689   package I = B;
690   Real x = I.a; 
691  end D;
692
693 D d;
694
695    annotation(__JModelica(UnitTesting(tests={
696        FlatteningTestCase(
697            name="NameTest22",
698            description="Chain of short class declarations",
699            flatModel="
700fclass NameTests.NameTest22
701 Real d.x = 3.0;
702end NameTests.NameTest22;
703")})));
704end NameTest22;
705
706
707model NameTest23
708        model A
709                Real x;
710        end A;
711       
712        model B
713                parameter Integer n;
714                A[n] a;
715                Real[n] y = a.x;
716        end B;
717       
718        model C
719                parameter Integer m;
720                B[m] b(n = 1:m);
721        end C;
722       
723        C c(m = 4);
724end NameTest23;
725
726
727model NameTest24
728    model A
729        replaceable B b constrainedby B;
730    end A;
731   
732    model B
733        Real x;
734    end B;
735   
736    model C
737        Real x = 1;
738        Real y = x;
739    end C;
740   
741    A a(redeclare C b);
742    Real z = a.b.y;
743
744        annotation(__JModelica(UnitTesting(tests={
745                FlatteningTestCase(
746                        name="NameTest24",
747                        description="",
748                        flatModel="
749fclass NameTests.NameTest24
750 Real a.b.x = 1;
751 Real a.b.y = a.b.x;
752 Real z = a.b.y;
753end NameTests.NameTest24;
754")})));
755end NameTest24;
756
757
758model NameTest25_Err
759    model A
760        replaceable B b constrainedby B;
761    end A;
762   
763    model B
764        Real x;
765    end B;
766   
767    model C
768        Real x = 1;
769        Real y = x;
770    end C;
771   
772    A a(redeclare replaceable C b);
773    Real z = a.b.y;
774
775    annotation(__JModelica(UnitTesting(tests={
776        WarningTestCase(
777            name="NameTest25_Err",
778            description="Check that member lookup is limited by constraining class when using redeclare replaceable",
779            errorMessage="
7801 warnings found:
781
782Warning at line 16, column 18, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NOT_IN_CONSTRAINING_TYPE:
783  Access to component y not recommended, it is not present in constraining type of declaration 'replaceable B b constrainedby B'
784")})));
785end NameTest25_Err;
786
787
788model NameTest26
789    model A
790        Real x = time;
791    end A;
792   
793    model B = A(x(start = c));
794   
795    parameter Real c = 2;
796    B b;
797
798    annotation(__JModelica(UnitTesting(tests={
799        FlatteningTestCase(
800            name="NameTest26",
801            description="Test lookup of names used in modifiers in short class declarations",
802            flatModel="
803fclass NameTests.NameTest26
804 parameter Real c = 2 /* 2 */;
805 Real b.x(start = c) = time;
806end NameTests.NameTest26;
807")})));
808end NameTest26;
809
810
811model NameTest27
812    model A
813        Real x = time;
814    end A;
815   
816    model D
817        model B = A(x(start = c));
818   
819        parameter Real c = 2;
820       
821        B b;
822    end D;
823   
824    D d(c = 3);
825
826    annotation(__JModelica(UnitTesting(tests={
827        FlatteningTestCase(
828            name="NameTest27",
829            description="Test lookup of names used in modifiers in short class declarations",
830            flatModel="
831fclass NameTests.NameTest27
832 parameter Real d.c = 3 /* 3 */;
833 Real d.b.x(start = d.c) = time;
834end NameTests.NameTest27;
835")})));
836end NameTest27;
837
838
839model NameTest28
840    model A
841        Real x = time;
842    end A;
843   
844    model D
845        replaceable model B = A;
846        B b;
847    end D;
848   
849    model E
850        parameter Real c = 2;
851       
852        D d(redeclare model B = A(x(start = c)));
853    end E;
854   
855    E e(c = 3);
856
857    annotation(__JModelica(UnitTesting(tests={
858        FlatteningTestCase(
859            name="NameTest28",
860            description="Test lookup of names used in modifiers in short class declarations",
861            flatModel="
862fclass NameTests.NameTest28
863 parameter Real e.c = 3 /* 3 */;
864 Real e.d.b.x(start = e.c) = time;
865end NameTests.NameTest28;
866")})));
867end NameTest28;
868
869
870
871/* Used for tests ConstantLookup1-3. */
872constant Real constant_1 = 1.0;
873
874class ConstantLookup1
875 Real x = constant_1;
876
877        annotation(__JModelica(UnitTesting(tests={
878                FlatteningTestCase(
879                        name="ConstantLookup1",
880                        description="Constant lookup: simple lookup in enclosing class",
881                        flatModel="
882fclass NameTests.ConstantLookup1
883 Real x = 1.0;
884
885end NameTests.ConstantLookup1;
886")})));
887end ConstantLookup1;
888
889
890class ConstantLookup2
891 model Inner
892  Real x = constant_1;
893 end Inner;
894 
895 Inner i;
896
897        annotation(__JModelica(UnitTesting(tests={
898                FlatteningTestCase(
899                        name="ConstantLookup2",
900                        description="Constant lookup: lookup in second enclosing class",
901                        flatModel="
902fclass NameTests.ConstantLookup2
903 Real i.x = 1.0;
904
905end NameTests.ConstantLookup2;
906")})));
907end ConstantLookup2;
908
909
910class ConstantLookup3
911 constant Real constant_1 = 2.0;
912 
913 model Inner
914  Real x = constant_1;
915 end Inner;
916 
917 Inner i;
918
919        annotation(__JModelica(UnitTesting(tests={
920                FlatteningTestCase(
921                        name="ConstantLookup3",
922                        description="Constant lookup: enclosing class overriding constant in second enclosing class",
923                        flatModel="
924fclass NameTests.ConstantLookup3
925 constant Real constant_1 = 2.0;
926 Real i.x = 2.0;
927
928end NameTests.ConstantLookup3;
929")})));
930end ConstantLookup3;
931
932
933class ConstantLookup4
934 parameter Real p = Modelica.Constants.pi;
935
936        annotation(__JModelica(UnitTesting(tests={
937                FlatteningTestCase(
938                        name="ConstantLookup4",
939                        description="Constant lookup: directly from package",
940                        flatModel="
941fclass NameTests.ConstantLookup4
942 parameter Real p = 3.141592653589793 /* 3.141592653589793 */;
943
944end NameTests.ConstantLookup4;
945")})));
946end ConstantLookup4;
947
948
949class ConstantLookup5
950 import Modelica.Constants.*;
951 parameter Real p = pi;
952
953        annotation(__JModelica(UnitTesting(tests={
954                FlatteningTestCase(
955                        name="ConstantLookup5",
956                        description="Constant lookup: import all from enclosing class",
957                        flatModel="
958fclass NameTests.ConstantLookup5
959 parameter Real p = 3.141592653589793 /* 3.141592653589793 */;
960
961end NameTests.ConstantLookup5;
962")})));
963end ConstantLookup5;
964
965
966class ConstantLookup6
967 import C = Modelica.Constants;
968 parameter Real p = C.pi;
969
970        annotation(__JModelica(UnitTesting(tests={
971                FlatteningTestCase(
972                        name="ConstantLookup6",
973                        description="Constant lookup: import enclosing package with rename",
974                        flatModel="
975fclass NameTests.ConstantLookup6
976 parameter Real p = 3.141592653589793 /* 3.141592653589793 */;
977
978end NameTests.ConstantLookup6;
979")})));
980end ConstantLookup6;
981
982
983class ConstantLookup7
984 import Modelica.*;
985 parameter Real p = Constants.pi;
986
987        annotation(__JModelica(UnitTesting(tests={
988                FlatteningTestCase(
989                        name="ConstantLookup7",
990                        description="Constant lookup: import all in top package, access via enclosing class",
991                        flatModel="
992fclass NameTests.ConstantLookup7
993 parameter Real p = 3.141592653589793 /* 3.141592653589793 */;
994
995end NameTests.ConstantLookup7;
996")})));
997end ConstantLookup7;
998
999
1000class ConstantLookup8
1001 import pi2 = Modelica.Constants.pi;
1002 parameter Real p = pi2;
1003
1004        annotation(__JModelica(UnitTesting(tests={
1005                FlatteningTestCase(
1006                        name="ConstantLookup8",
1007                        description="Constant lookup: named import of specific constant",
1008                        flatModel="
1009fclass NameTests.ConstantLookup8
1010 parameter Real p = 3.141592653589793 /* 3.141592653589793 */;
1011
1012end NameTests.ConstantLookup8;
1013")})));
1014end ConstantLookup8;
1015
1016
1017class ConstantLookup9
1018 import Modelica.Constants.pi;
1019 parameter Real p = pi;
1020
1021        annotation(__JModelica(UnitTesting(tests={
1022                FlatteningTestCase(
1023                        name="ConstantLookup9",
1024                        description="Constant lookup: import of specific constant",
1025                        flatModel="
1026fclass NameTests.ConstantLookup9
1027 parameter Real p = 3.141592653589793 /* 3.141592653589793 */;
1028
1029end NameTests.ConstantLookup9;
1030")})));
1031end ConstantLookup9;
1032
1033
1034// TODO: Maybe the last error message each in ConstantLookup10-11 are redundant - let lookup succeed?
1035model ConstantLookup10
1036 package P
1037  parameter Real x;
1038 end P;
1039 
1040 import NameTests.ConstantLookup10.P.x;
1041 parameter Real p = x;
1042
1043    annotation(__JModelica(UnitTesting(tests={
1044        ErrorTestCase(
1045            name="ConstantLookup10",
1046            description="Constant lookup: trying to import non-constant component",
1047            errorMessage="
10482 errors found:
1049
1050Error at line 2, column 2, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
1051  Packages may only contain classes and constants
1052
1053Error at line 7, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
1054  Cannot find class or component declaration for x
1055")})));
1056end ConstantLookup10;
1057
1058
1059model ConstantLookup11
1060 package P
1061  parameter Real x;
1062 end P;
1063 
1064 import x2 = NameTests.ConstantLookup11.P.x;
1065 parameter Real p = x2;
1066
1067    annotation(__JModelica(UnitTesting(tests={
1068        ErrorTestCase(
1069            name="ConstantLookup11",
1070            description="Constant lookup: trying to import non-constant component (named import)",
1071            errorMessage="
10722 errors found:
1073
1074Error at line 2, column 2, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
1075  Packages may only contain classes and constants
1076
1077Error at line 7, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
1078  Cannot find class or component declaration for x2
1079")})));
1080end ConstantLookup11;
1081
1082
1083// TODO: Maybe a better error message is needed here
1084model ConstantLookup12
1085 package P
1086  parameter Real x;
1087 end P;
1088 
1089 import NameTests.ConstantLookup12.P.*;
1090 parameter Real p = x;
1091
1092    annotation(__JModelica(UnitTesting(tests={
1093        ErrorTestCase(
1094            name="ConstantLookup12",
1095            description="Constant lookup: trying to import non-constant component (unqualified import)",
1096            errorMessage="
10971 errors found:
1098
1099Error at line 7, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
1100  Cannot find class or component declaration for x
1101")})));
1102end ConstantLookup12;
1103
1104
1105/* TODO: Tests ConstantLookup13-15 should produce errors. Add annotations 
1106 *       when there are error checks for accesses to protected elements. */
1107class ConstantLookup13
1108  package P
1109  protected
1110    constant Real prot = 1.0;
1111  end P;
1112 
1113  import NameTests.ConstantLookup13.P.*;
1114  parameter Real p = prot;
1115end ConstantLookup13;
1116
1117
1118class ConstantLookup14
1119  package P
1120  protected
1121    constant Real prot = 1.0;
1122  end P;
1123 
1124  import NameTests.ConstantLookup14.P.prot;
1125  parameter Real p = prot;
1126end ConstantLookup14;
1127
1128
1129class ConstantLookup15
1130  package P
1131  protected
1132    constant Real prot = 1.0;
1133  end P;
1134 
1135  import prot2 = NameTests.ConstantLookup15.P.prot;
1136  parameter Real p = prot2;
1137end ConstantLookup15;
1138
1139
1140model ConstantLookup16
1141        constant Real a = b[c];
1142        constant Real[3] b = {1, 2, 3};
1143        constant Integer c = d;
1144
1145    annotation(__JModelica(UnitTesting(tests={
1146        ErrorTestCase(
1147            name="ConstantLookup16",
1148            description="Using constant with bad value as array index",
1149            errorMessage="
11502 errors found:
1151
1152Error at line 2, column 20, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
1153  Could not evaluate binding expression for constant 'a': 'b[c]'
1154    Cannot get int value of CValueUnknown
1155
1156Error at line 4, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
1157  Cannot find class or component declaration for d
1158")})));
1159end ConstantLookup16;
1160
1161
1162model ConstantLookup17
1163        package A
1164                parameter Integer n = 2;
1165        end A;
1166       
1167        model B
1168                constant Integer n = 3;
1169        end B;
1170       
1171        Real a = A.n;
1172        Real b = B.n;
1173
1174    annotation(__JModelica(UnitTesting(tests={
1175        ErrorTestCase(
1176            name="ConstantLookup17",
1177            description="Illegal accesses of components in local classes",
1178            errorMessage="
11791 errors found:
1180
1181Error at line 2, column 2, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
1182  Packages may only contain classes and constants
1183")})));
1184end ConstantLookup17;
1185
1186
1187model ConstantLookup18
1188   model A
1189       parameter Integer n;
1190       Real x[n] = fill(1, n);
1191   end A;
1192   
1193   model B
1194       extends A(n = C.f.n);
1195       replaceable package C = D;
1196   end B;
1197   
1198   package D
1199       extends E;
1200   end D;
1201   
1202   package E
1203       constant F f = F(3);
1204   end E;
1205   
1206   record F
1207       Integer n;
1208   end F;
1209   
1210   B b;
1211
1212        annotation(__JModelica(UnitTesting(tests={
1213                TransformCanonicalTestCase(
1214                        name="ConstantLookup18",
1215                        description="Member of constant record, using record constructor, through inheritance and short class decl",
1216            eliminate_alias_variables=false,
1217                        flatModel="
1218fclass NameTests.ConstantLookup18
1219 structural parameter Integer b.n = 3 /* 3 */;
1220 constant Real b.x[1] = 1;
1221 constant Real b.x[2] = 1;
1222 constant Real b.x[3] = 1;
1223end NameTests.ConstantLookup18;
1224")})));
1225end ConstantLookup18;
1226
1227
1228model ConstantLookup19
1229    package A
1230        constant Integer n;
1231        model AA
1232            Real x[n] = fill(1, n);
1233        end AA;
1234    end A;
1235   
1236    package B
1237        extends A(n = C.f.n);
1238        replaceable package C = D;
1239    end B;
1240   
1241    package D
1242        extends E;
1243    end D;
1244   
1245    package E
1246        constant F f;
1247    end E;
1248   
1249    record F
1250        Integer n;
1251    end F;
1252   
1253    package G
1254        extends B(redeclare package C = H);
1255    end G;
1256   
1257    package H
1258        extends E(f(n=3));
1259    end H;
1260   
1261    G.AA y;
1262
1263        annotation(__JModelica(UnitTesting(tests={
1264                FlatteningTestCase(
1265                        name="ConstantLookup19",
1266                        description="Using package constant set through redeclare and several levels of inheritance",
1267                        flatModel="
1268fclass NameTests.ConstantLookup19
1269 Real y.x[3] = fill(1, 3);
1270
1271end NameTests.ConstantLookup19;
1272")})));
1273end ConstantLookup19;
1274
1275
1276model ConstantLookup20
1277   package A
1278           constant B b = B(3);
1279   end A;
1280   
1281   record B
1282           Real x;
1283   end B;
1284   
1285   Real y = A.b.x;
1286
1287        annotation(__JModelica(UnitTesting(tests={
1288                TransformCanonicalTestCase(
1289                        name="ConstantLookup20",
1290                        description="Member of constant record, using record constructor",
1291                        flatModel="
1292fclass NameTests.ConstantLookup20
1293 constant Real y = 3.0;
1294end NameTests.ConstantLookup20;
1295")})));
1296end ConstantLookup20;
1297
1298
1299model ConstantLookup21
1300    model A
1301        replaceable package B = C constrainedby D;
1302        Real x[B.n] = ones(B.n);
1303    end A;
1304   
1305    package C
1306        constant Integer n = 2;
1307    end C;
1308   
1309    package D
1310        constant Integer n;
1311    end D;
1312   
1313    A a;
1314
1315        annotation(__JModelica(UnitTesting(tests={
1316                FlatteningTestCase(
1317                        name="ConstantLookup21",
1318                        description="Lookup of package constant through short class decl with constrainedby",
1319                        flatModel="
1320fclass NameTests.ConstantLookup21
1321 Real a.x[2] = ones(2);
1322
1323end NameTests.ConstantLookup21;
1324")})));
1325end ConstantLookup21;
1326
1327
1328model ConstantLookup22
1329    partial package A
1330        replaceable partial model M = B;
1331        end A;
1332       
1333        partial model B
1334                replaceable package N = E;
1335                input Real[N.b] a;
1336        end B;
1337       
1338        model C
1339                extends B(redeclare replaceable package N = F constrainedby G);
1340        end C;
1341               
1342        package D
1343                extends F;
1344                extends A(redeclare model M = C(redeclare package N = F));
1345        end D;
1346         
1347        partial package E
1348                constant Integer b(min=1);
1349        end E;
1350                 
1351        package F
1352                extends G(redeclare package O = H);
1353        end F;
1354                 
1355        package G
1356                extends E(b=O.c.g);
1357                replaceable package O = J;
1358        end G;
1359                 
1360        package H
1361                extends I(c(g=2));
1362        end H;
1363                         
1364        package I
1365                extends J;
1366        end I;
1367                         
1368        package J
1369                constant K c;
1370        end J;
1371                 
1372        record K
1373                parameter Integer g;
1374        end K;
1375       
1376        model L
1377                replaceable package P = D constrainedby M;
1378                P.M d(a=e);
1379                Real[P.b] e = ones(P.b);
1380        end L;
1381       
1382        package M
1383                extends A;
1384                extends E;
1385        end M;
1386       
1387        L f;
1388
1389        annotation(__JModelica(UnitTesting(tests={
1390                FlatteningTestCase(
1391                        name="ConstantLookup22",
1392                        description="Class lookup through redeclares with constrainedby, complex example",
1393                        flatModel="
1394fclass NameTests.ConstantLookup22
1395 Real f.d.a[2] = f.e[1:2];
1396 Real f.e[2] = ones(2);
1397
1398end NameTests.ConstantLookup22;
1399")})));
1400end ConstantLookup22;
1401
1402
1403model ConstantLookup23
1404        package A
1405        end A;
1406       
1407        package B
1408                constant Real x = 1.0;
1409        end B;
1410       
1411        replaceable package C = B constrainedby A;
1412       
1413        Real y = C.x;
1414
1415    annotation(__JModelica(UnitTesting(tests={
1416        WarningTestCase(
1417            name="ConstantLookup23",
1418            description="Trying to use member that does not exist in constraining class (but does in actual)",
1419            errorMessage="
14201 warnings found:
1421
1422Warning at line 11, column 13, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NOT_IN_CONSTRAINING_TYPE:
1423  Access to component x not recommended, it is not present in constraining type of declaration 'replaceable package C = B constrainedby A'
1424")})));
1425end ConstantLookup23;
1426
1427
1428// TODO: C.d is here evaluated to either 0.0 or 1.0, depending on the order of the extends clauses
1429model ConstantLookup24
1430    package A
1431        constant Real d = 1.0;
1432    end A;
1433   
1434    package B
1435        constant Real d;
1436    end B;
1437   
1438    package C
1439        extends A;
1440        extends B;
1441    end C;
1442   
1443    Real x = C.d;
1444end ConstantLookup24;
1445
1446
1447model ConstantLookup25
1448        record A
1449                Real a;
1450        end A;
1451       
1452        constant A x[:] = { A(1), A(2) };
1453    constant Real y[2] = x.a;
1454        Real z[2] = y;
1455
1456        annotation(__JModelica(UnitTesting(tests={
1457                FlatteningTestCase(
1458                        name="ConstantLookup25",
1459                        description="Slice over array of components, declared with : size",
1460                        flatModel="
1461fclass NameTests.ConstantLookup25
1462 constant NameTests.ConstantLookup25.A x[2] = {NameTests.ConstantLookup25.A(1), NameTests.ConstantLookup25.A(2)};
1463 constant Real y[2] = {1, 2};
1464 Real z[2] = {1.0, 2.0};
1465
1466public
1467 record NameTests.ConstantLookup25.A
1468  Real a;
1469 end NameTests.ConstantLookup25.A;
1470
1471end NameTests.ConstantLookup25;
1472")})));
1473end ConstantLookup25;
1474
1475
1476// This is not a test class
1477package ExtraForConstantLookup26
1478        partial package A
1479                extends B(d = size(b, 1), c = b[:].a);
1480               
1481                record C
1482                        Real a;
1483                end C;
1484               
1485                constant C[:] b;
1486        end A;
1487       
1488        package B
1489                constant Integer d;
1490                constant Real[d] c;
1491        end B;
1492       
1493        package D
1494                extends A;
1495        end D;
1496       
1497        package E
1498                constant F.G[:] e = { F.f, F.g };
1499                extends D(b = e);
1500        end E;
1501       
1502        package F
1503                record G
1504                        Real a;
1505                end G;
1506               
1507                constant G f(a = 1);
1508                constant G g(a = 2);
1509        end F;
1510end ExtraForConstantLookup26;
1511
1512model ConstantLookup26
1513    constant Real x[2] = ExtraForConstantLookup26.E.c;
1514        Real y[2] = x;
1515
1516        annotation(__JModelica(UnitTesting(tests={
1517                FlatteningTestCase(
1518                        name="ConstantLookup26",
1519                        description="Constant lookup in complex data structure",
1520                        flatModel="
1521fclass NameTests.ConstantLookup26
1522 constant Real x[2] = {1, 2};
1523 Real y[2] = {1.0, 2.0};
1524end NameTests.ConstantLookup26;
1525")})));
1526end ConstantLookup26;
1527
1528
1529model ConstantLookup27
1530        record A
1531                Real a;
1532                Real b;
1533        end A;
1534       
1535        constant A c = A(1, 2);
1536       
1537        package B
1538                constant A d = A(3, 4);
1539        end B;
1540       
1541        package C
1542                extends B(d = c);
1543        end C;
1544       
1545        constant Real e[2] = { C.d.a, C.d.b };
1546        Real f[2] = e;
1547
1548        annotation(__JModelica(UnitTesting(tests={
1549                FlatteningTestCase(
1550                        name="ConstantLookup27",
1551                        description="Access to record as modification",
1552                        flatModel="
1553fclass NameTests.ConstantLookup27
1554 constant NameTests.ConstantLookup27.A c = NameTests.ConstantLookup27.A(1, 2);
1555 constant Real e[2] = {1, 2};
1556 Real f[2] = {1.0, 2.0};
1557
1558public
1559 record NameTests.ConstantLookup27.A
1560  Real a;
1561  Real b;
1562 end NameTests.ConstantLookup27.A;
1563
1564end NameTests.ConstantLookup27;
1565")})));
1566end ConstantLookup27;
1567
1568
1569model ConstantLookup28
1570        package A
1571                constant Real a = 2;
1572        end A;
1573       
1574        package B
1575                extends C;
1576               
1577                model D
1578                        Real x = a;
1579                end D;
1580        end B;
1581       
1582        package C
1583                extends A;
1584        end C;
1585       
1586        B.D y;
1587
1588        annotation(__JModelica(UnitTesting(tests={
1589                FlatteningTestCase(
1590                        name="ConstantLookup28",
1591                        description="",
1592                        flatModel="
1593fclass NameTests.ConstantLookup28
1594 Real y.x = 2.0;
1595
1596end NameTests.ConstantLookup28;
1597")})));
1598end ConstantLookup28;
1599
1600
1601model ConstantLookup29
1602  package A
1603          constant Real c1 = 1;
1604  end A;
1605
1606  model B
1607        import NameTests.ConstantLookup29.A.*;
1608        Real x(start=c1)=2;
1609  end B;
1610
1611  model C
1612        extends B;
1613  end C;
1614 
1615  C a;
1616
1617        annotation(__JModelica(UnitTesting(tests={
1618                TransformCanonicalTestCase(
1619                        name="ConstantLookup29",
1620                        description="Extending class using imported constant",
1621                        flatModel="
1622fclass NameTests.ConstantLookup29
1623 constant Real a.x(start = 1.0) = 2;
1624end NameTests.ConstantLookup29;
1625")})));
1626end ConstantLookup29;
1627
1628
1629model ConstantLookup30
1630        package Constants
1631                constant Real c = 3.1;
1632        end Constants;
1633       
1634        model M1
1635                import NameTests.ConstantLookup30.Constants.*;
1636                import SI = Modelica.SIunits;
1637                parameter Real p = c;
1638                SI.Force f=1; 
1639        end M1;
1640       
1641        extends M1;
1642
1643        annotation(__JModelica(UnitTesting(tests={
1644                TransformCanonicalTestCase(
1645                        name="ConstantLookup30",
1646                        description="",
1647                        flatModel="
1648fclass NameTests.ConstantLookup30
1649 parameter Real p = 3.1 /* 3.1 */;
1650 constant Modelica.SIunits.Force f = 1;
1651
1652public
1653 type Modelica.SIunits.Force = Real(final quantity = \"Force\",final unit = \"N\");
1654end NameTests.ConstantLookup30;
1655")})));
1656end ConstantLookup30;
1657
1658
1659package ConstantLookup31
1660        constant Integer c = 1;
1661        package NameTests
1662                package ConstantLookup31
1663                        constant Integer c = 2;
1664                        model ConstantLookup31_m
1665                                constant Integer a = .NameTests.ConstantLookup31.c;
1666                                constant Integer b = NameTests.ConstantLookup31.c;
1667
1668        annotation(__JModelica(UnitTesting(tests={
1669                FlatteningTestCase(
1670                        name="ConstantLookup31_m",
1671                        description="Lookup of names starting with .",
1672                        flatModel="
1673fclass NameTests.ConstantLookup31.NameTests.ConstantLookup31.ConstantLookup31_m
1674 constant Integer a = 1;
1675 constant Integer b = 2;
1676
1677end NameTests.ConstantLookup31.NameTests.ConstantLookup31.ConstantLookup31_m;
1678")})));
1679                        end ConstantLookup31_m;
1680                end ConstantLookup31;
1681        end NameTests;
1682       
1683end ConstantLookup31;
1684
1685
1686model ConstantLookup32
1687    record A
1688        Real b;
1689    end A;
1690   
1691    package C
1692        constant A[2] d = { A(3), A(4) };
1693    end C;
1694   
1695    function f
1696        input Integer i;
1697        output Real x;
1698    algorithm
1699        x := C.d[i].b;
1700    end f;
1701   
1702    parameter Integer j = 1;
1703    Real y = f(j);
1704
1705        annotation(__JModelica(UnitTesting(tests={
1706                FlatteningTestCase(
1707                        name="ConstantLookup32",
1708                        description="Package constants in functions for complex accesses",
1709                        flatModel="
1710fclass NameTests.ConstantLookup32
1711 parameter Integer j = 1 /* 1 */;
1712 Real y = NameTests.ConstantLookup32.f(j);
1713global variables
1714 constant NameTests.ConstantLookup32.A NameTests.ConstantLookup32.C.d[2] = {NameTests.ConstantLookup32.A(3), NameTests.ConstantLookup32.A(4)};
1715
1716public
1717 function NameTests.ConstantLookup32.f
1718  input Integer i;
1719  output Real x;
1720 algorithm
1721  x := global(NameTests.ConstantLookup32.C.d[i].b);
1722  return;
1723 end NameTests.ConstantLookup32.f;
1724
1725 record NameTests.ConstantLookup32.A
1726  Real b;
1727 end NameTests.ConstantLookup32.A;
1728
1729end NameTests.ConstantLookup32;
1730")})));
1731end ConstantLookup32;
1732
1733
1734model ConstantLookup33
1735        package D
1736            record A
1737                Real b;
1738            end A;
1739        end D;
1740       
1741        package F
1742                constant D.A[2] d;
1743        end F;
1744   
1745    package C
1746                package E = D;
1747                constant E.A g = E.A(3);
1748                constant E.A h = E.A(4);
1749        extends F(d = { g, h });
1750    end C;
1751   
1752    function f
1753        input Integer i;
1754        output Real x;
1755    algorithm
1756        x := C.d[i].b;
1757    end f;
1758   
1759    parameter Integer j = 1;
1760    Real y = f(j);
1761
1762        annotation(__JModelica(UnitTesting(tests={
1763                FlatteningTestCase(
1764                        name="ConstantLookup33",
1765                        description="Package constants in functions for complex accesses",
1766                        flatModel="
1767fclass NameTests.ConstantLookup33
1768 parameter Integer j = 1 /* 1 */;
1769 Real y = NameTests.ConstantLookup33.f(j);
1770global variables
1771 constant NameTests.ConstantLookup33.D.A NameTests.ConstantLookup33.C.d[2] = {NameTests.ConstantLookup33.D.A(3), NameTests.ConstantLookup33.D.A(4)};
1772
1773public
1774 function NameTests.ConstantLookup33.f
1775  input Integer i;
1776  output Real x;
1777 algorithm
1778  x := global(NameTests.ConstantLookup33.C.d[i].b);
1779  return;
1780 end NameTests.ConstantLookup33.f;
1781
1782 record NameTests.ConstantLookup33.D.A
1783  Real b;
1784 end NameTests.ConstantLookup33.D.A;
1785
1786end NameTests.ConstantLookup33;
1787")})));
1788end ConstantLookup33;
1789
1790
1791model ConstantLookup34
1792    package A
1793        constant B[2] x = { B({1,2}), B({3,4}) };
1794       
1795        record B
1796            Real[2] y;
1797        end B;
1798    end A;
1799   
1800    function f
1801        input Integer i;
1802        output Real x;
1803    algorithm
1804        x := A.x[i].y[i];
1805        annotation(Inline=false);
1806    end f;
1807   
1808    parameter Integer j = 1;
1809    Real z = f(j);
1810
1811        annotation(__JModelica(UnitTesting(tests={
1812                TransformCanonicalTestCase(
1813                        name="ConstantLookup34",
1814                        description="Constant in function being used in a manner that triggers the algorithm that includes packag constants in functions",
1815                        flatModel="
1816fclass NameTests.ConstantLookup34
1817 parameter Integer j = 1 /* 1 */;
1818 parameter Real z;
1819global variables
1820 constant NameTests.ConstantLookup34.A.B NameTests.ConstantLookup34.A.x[2] = {NameTests.ConstantLookup34.A.B({1, 2}), NameTests.ConstantLookup34.A.B({3, 4})};
1821parameter equation
1822 z = NameTests.ConstantLookup34.f(j);
1823
1824public
1825 function NameTests.ConstantLookup34.f
1826  input Integer i;
1827  output Real x;
1828 algorithm
1829  x := global(NameTests.ConstantLookup34.A.x[i].y[i]);
1830  return;
1831 annotation(Inline = false);
1832 end NameTests.ConstantLookup34.f;
1833
1834 record NameTests.ConstantLookup34.A.B
1835  Real y[2];
1836 end NameTests.ConstantLookup34.A.B;
1837
1838end NameTests.ConstantLookup34;
1839")})));
1840end ConstantLookup34;
1841
1842
1843model ConstantLookup35
1844        package A = B;
1845        D b(redeclare package C = A);
1846       
1847        model D
1848                replaceable package C = B constrainedby E;
1849                parameter Integer j = 1;
1850                Real z = C.F.f1(j);
1851        end D;
1852       
1853        package G
1854        replaceable package H = I;
1855       
1856                partial function f1
1857                        input Integer i;
1858                        output Real x;
1859                end f1;
1860        end G;
1861       
1862        package B
1863                extends E(redeclare package F = J);
1864        end B;
1865       
1866        package J
1867                extends K(redeclare package H = L);
1868        end J;
1869       
1870        package K
1871                extends G;
1872               
1873                redeclare function extends f1
1874                protected
1875                        Real y = H.a[i];
1876                algorithm
1877                        x := y;
1878                end f1;
1879        end K;
1880       
1881        package L
1882                extends I(a = {1,2});
1883        end L;
1884       
1885        package I
1886                constant Real[2] a = {3,4};
1887        end I;
1888       
1889        package E
1890                replaceable package F = G;
1891        end E;
1892
1893        annotation(__JModelica(UnitTesting(tests={
1894                TransformCanonicalTestCase(
1895                        name="ConstantLookup35",
1896                        description="Package constants in functions where getFQName() gives two-part name",
1897                        flatModel="
1898fclass NameTests.ConstantLookup35
1899 parameter Integer b.j = 1 /* 1 */;
1900 parameter Real b.z;
1901global variables
1902 constant Real NameTests.ConstantLookup35.L.a[2] = {1, 2};
1903parameter equation
1904 b.z = NameTests.ConstantLookup35.J.f1(b.j);
1905
1906public
1907 function NameTests.ConstantLookup35.J.f1
1908  input Integer i;
1909  output Real x;
1910  Real y;
1911 algorithm
1912  y := global(NameTests.ConstantLookup35.L.a[i]);
1913  x := y;
1914  return;
1915 end NameTests.ConstantLookup35.J.f1;
1916
1917end NameTests.ConstantLookup35;
1918")})));
1919end ConstantLookup35;
1920
1921
1922model ConstantLookup36
1923    record B
1924        Real[2] b;
1925    end B;
1926   
1927    function f
1928        input Integer i;
1929        output Real x;
1930        protected
1931                constant B[2] a = { B({1,2}), B({3,4}) };
1932    algorithm
1933        x := a[i].b[i];
1934        annotation(Inline=false);
1935    end f;
1936   
1937    parameter Integer j = 1;
1938    Real z = f(j);
1939
1940        annotation(__JModelica(UnitTesting(tests={
1941                TransformCanonicalTestCase(
1942                        name="ConstantLookup36",
1943                        description="",
1944                        flatModel="
1945fclass NameTests.ConstantLookup36
1946 parameter Integer j = 1 /* 1 */;
1947 parameter Real z;
1948global variables
1949 constant NameTests.ConstantLookup36.B NameTests.ConstantLookup36.f.a[2] = {NameTests.ConstantLookup36.B({1, 2}), NameTests.ConstantLookup36.B({3, 4})};
1950parameter equation
1951 z = NameTests.ConstantLookup36.f(j);
1952
1953public
1954 function NameTests.ConstantLookup36.f
1955  input Integer i;
1956  output Real x;
1957 algorithm
1958  x := global(NameTests.ConstantLookup36.f.a[i].b[i]);
1959  return;
1960 annotation(Inline = false);
1961 end NameTests.ConstantLookup36.f;
1962
1963 record NameTests.ConstantLookup36.B
1964  Real b[2];
1965 end NameTests.ConstantLookup36.B;
1966
1967end NameTests.ConstantLookup36;
1968")})));
1969end ConstantLookup36;
1970
1971
1972model ConstantLookup37
1973    package A
1974        constant Real e = 2;
1975               
1976        package B
1977            constant Real g = 1;
1978            extends C(f = e);
1979        end B;
1980    end A;
1981   
1982    package C
1983        constant Real f = 1;
1984    end C;
1985   
1986    package D = A.B(g = 3);
1987   
1988    Real z = D.f;
1989
1990        annotation(__JModelica(UnitTesting(tests={
1991                FlatteningTestCase(
1992                        name="ConstantLookup37",
1993                        description="Package constant through hierarchical lookup from extended class",
1994                        flatModel="
1995fclass NameTests.ConstantLookup37
1996 Real z = 2.0;
1997end NameTests.ConstantLookup37;
1998")})));
1999end ConstantLookup37;
2000
2001
2002model ConstantLookup38
2003    package A
2004        constant Real e = 2;
2005               
2006        package B
2007            constant Real g = 1;
2008                        constant Real f = e;
2009        end B;
2010    end A;
2011   
2012    package D = A.B(g = 3);
2013   
2014    Real z = D.f;
2015
2016        annotation(__JModelica(UnitTesting(tests={
2017                FlatteningTestCase(
2018                        name="ConstantLookup38",
2019                        description="Package constant through hierarchical lookup from extended class",
2020                        flatModel="
2021fclass NameTests.ConstantLookup38
2022 Real z = 2.0;
2023end NameTests.ConstantLookup38;
2024")})));
2025end ConstantLookup38;
2026
2027
2028package ExtraForConstantLookup39
2029    package B
2030        extends C(f = e);
2031    end B;
2032       
2033    package C
2034        constant Real f = 1;
2035    end C;
2036end ExtraForConstantLookup39;
2037
2038model ConstantLookup39
2039    package D = ExtraForConstantLookup39.B;
2040   
2041    Real z = D.f;
2042
2043    annotation(__JModelica(UnitTesting(tests={
2044        ErrorTestCase(
2045            name="ConstantLookup39",
2046            description="Error in constant used from other package",
2047            errorMessage="
20481 errors found:
2049
2050Error at line -7, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
2051  Cannot find class or component declaration for e
2052")})));
2053end ConstantLookup39;
2054
2055
2056model ConstantLookup40
2057    model A
2058        constant Real x = 2;
2059    end A;
2060   
2061    parameter Real y = A.x;
2062end ConstantLookup40;
2063
2064model ConstantLookup41
2065    class P1
2066        Real x;
2067    end P1;
2068   
2069    package P2
2070        extends P1;
2071    end P2;
2072
2073    Real x = P2.x;
2074
2075    annotation(__JModelica(UnitTesting(tests={
2076        ErrorTestCase(
2077            name="ConstantLookup41",
2078            description="Constant lookup: in not ok package",
2079            errorMessage="
2080Error at line 6, column 5, in file '...':
2081  Packages may only contain classes and constants
2082")})));
2083end ConstantLookup41;
2084
2085model ConstantLookup42
2086    class P1
2087        constant Real x;
2088    equation
2089        x = 1;
2090    end P1;
2091   
2092    package P2
2093        extends P1;
2094    end P2;
2095
2096    Real x = P2.x;
2097
2098    annotation(__JModelica(UnitTesting(tests={
2099        ErrorTestCase(
2100            name="ConstantLookup42",
2101            description="Constant lookup: in not ok package",
2102            errorMessage="
2103Error at line 8, column 5, in file '...':
2104  Packages may only contain classes and constants
2105")})));
2106end ConstantLookup42;
2107
2108class ExtendsTest1
2109  class C
2110    Real x;
2111  end C;
2112 
2113  class C2
2114        extends C;
2115    class C3
2116      extends C;
2117      equation 
2118        x=1;
2119    end C3;
2120    C3 c3;
2121    equation
2122      x=2;
2123  end C2;
2124  extends C;
2125  C2 c2;
2126  equation
2127    x=3;
2128
2129        annotation(__JModelica(UnitTesting(tests={
2130                FlatteningTestCase(
2131                        name="ExtendsTest1",
2132                        description="Simple use of extends",
2133                        flatModel="
2134 fclass NameTests.ExtendsTest1
2135 Real c2.c3.x;
2136 Real c2.x;
2137 Real x;
2138equation 
2139 x=3;
2140 c2.x=2;
2141 c2.c3.x=1;
2142end NameTests.ExtendsTest1;
2143 
2144")})));
2145end ExtendsTest1;
2146
2147class ExtendsTest2
2148  class C
2149    class D
2150      Real x;
2151    end D;
2152  end C;
2153  extends C;
2154  D d;
2155  equation
2156  d.x=3;
2157
2158        annotation(__JModelica(UnitTesting(tests={
2159                FlatteningTestCase(
2160                        name="ExtendsTest2",
2161                        description="Test component declaration using a local class that becomes visible through inheritance",
2162                        flatModel="
2163fclass NameTests.ExtendsTest2
2164 Real d.x;
2165equation 
2166 d.x=3;
2167
2168end NameTests.ExtendsTest2;
2169")})));
2170end ExtendsTest2;
2171
2172model ExtendsTest3
2173  class C
2174    class D
2175      Real x;
2176    end D;
2177  end C;
2178  extends C;
2179  extends D;
2180
2181    annotation(__JModelica(UnitTesting(tests={
2182        ErrorTestCase(
2183            name="ExtendsTest3",
2184            description="Test that local classes that becomes visible through inheritance can not be used as super classes",
2185            errorMessage="
21861 errors found:
2187
2188Error at line 8, column 11, in file 'Compiler/ModelicaFrontEnd/src/test/NameTests.mo':
2189  Cannot find class declaration for D
2190")})));
2191end ExtendsTest3;
2192
2193model ExtendsTest4
2194  package A
2195    model C
2196      Real d = 1;
2197    end C;
2198    model B
2199      extends A.C;
2200    end B;
2201  end A;
2202
2203  A.B e[2];
2204  Real y;
2205equation
2206  y = e[1].d;
2207
2208        annotation(__JModelica(UnitTesting(tests={
2209                FlatteningTestCase(
2210                        name="ExtendsTest4",
2211                        description="Array of components of a class extending class with components",
2212                        flatModel="
2213fclass NameTests.ExtendsTest4
2214 Real e[1].d = 1;
2215 Real e[2].d = 1;
2216 Real y;
2217equation
2218 y = e[1].d;
2219
2220end NameTests.ExtendsTest4;
2221")})));
2222end ExtendsTest4;
2223
2224
2225model ImportTest1
2226 
2227  package P
2228    model A
2229      Real x;
2230    end A;
2231    model B
2232      Real y;
2233    end B;
2234  end P;
2235 
2236  import NameTests.ImportTest1.P.*;
2237  // import Modelica.SIunits.*;
2238 
2239  A a;
2240  extends A;
2241  B b;
2242  extends B;
2243 
2244
2245        annotation(__JModelica(UnitTesting(tests={
2246                FlatteningTestCase(
2247                        name="ImportTest1",
2248                        description="Test circular dependency of unqualified import and extends.",
2249                        flatModel="
2250fclass NameTests.ImportTest1
2251 Real a.x;
2252 Real b.y;
2253 Real x;
2254 Real y;
2255
2256end NameTests.ImportTest1;
2257")})));
2258end ImportTest1;
2259
2260model ImportTest2
2261  package P
2262    model A
2263      Real x;
2264    end A;
2265    model B
2266      Real y;
2267    end B;
2268  end P;
2269 
2270  import NameTests.ImportTest2.P.A;
2271  A a;
2272  extends A;
2273 
2274 
2275 
2276
2277        annotation(__JModelica(UnitTesting(tests={
2278                FlatteningTestCase(
2279                        name="ImportTest2",
2280                        description="Test of qualified import.",
2281                        flatModel="
2282fclass NameTests.ImportTest2
2283 Real a.x;
2284 Real x;
2285
2286end NameTests.ImportTest2;
2287")})));
2288end ImportTest2;
2289
2290model ImportTest3
2291  package P
2292    model A
2293      Real x;
2294    end A;
2295    model B
2296      Real y;
2297    end B;
2298  end P;
2299 
2300  import NameTests.ImportTest1.P.A;
2301  A a;
2302  extends A;
2303  B b;
2304 
2305
2306    annotation(__JModelica(UnitTesting(tests={
2307        ErrorTestCase(
2308            name="ImportTest3",
2309            description="Test that only a class imported with qualified import is visible.",
2310            errorMessage="
23111 errors found:
2312
2313Error at line 14, column 3, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
2314  Cannot find class declaration for B
2315")})));
2316end ImportTest3;
2317
2318
2319model ImportTest4
2320  package P
2321    model A
2322      Real x;
2323    end A;
2324  end P;
2325 
2326  import PP = NameTests.ImportTest1.P;
2327  PP.A a;
2328  extends PP.A;
2329 
2330
2331        annotation(__JModelica(UnitTesting(tests={
2332                FlatteningTestCase(
2333                        name="ImportTest4",
2334                        description="Test alias import.",
2335                        flatModel="
2336fclass NameTests.ImportTest4
2337 Real a.x;
2338 Real x;
2339
2340end NameTests.ImportTest4;
2341")})));
2342end ImportTest4;
2343
2344model ImportTest5
2345  package P
2346    model A
2347      Real x=0;
2348    end A;
2349   
2350    model B
2351      Real y=1;
2352    end B;
2353   
2354    model C
2355      model D
2356        Real z=2;
2357      end D;
2358    end C;
2359   
2360  end P;
2361   
2362  import NameTests.ImportTest5.P.C.*;
2363  D d(z=3);
2364 
2365
2366        annotation(__JModelica(UnitTesting(tests={
2367                FlatteningTestCase(
2368                        name="ImportTest5",
2369                        description="Test circular dependency between import and extends: import of class that becomes visible through inheritance",
2370                        flatModel="
2371fclass NameTests.ImportTest5
2372 Real d.z=3;
2373
2374end NameTests.ImportTest5;
2375")})));
2376end ImportTest5;
2377
2378
2379model ImportTest6
2380  package P
2381        model M
2382                import SI = NameTests.ImportTest6.P.SIunits;
2383                SI.Resistance R(start=1);
2384        end M;
2385       
2386    package SIunits
2387        type Resistance = Real(unit="Ohm");
2388    end SIunits;
2389 
2390  end P;
2391
2392  P.M m;
2393
2394
2395        annotation(__JModelica(UnitTesting(tests={
2396                FlatteningTestCase(
2397                        name="ImportTest6",
2398                        description="Test name lookup in a more complex case",
2399                        flatModel="
2400fclass NameTests.ImportTest6
2401 NameTests.ImportTest6.P.SIunits.Resistance m.R(start = 1);
2402
2403public
2404 type NameTests.ImportTest6.P.SIunits.Resistance = Real(unit = \"Ohm\");
2405end NameTests.ImportTest6;
2406")})));
2407end ImportTest6;
2408
2409model ImportTest7
2410  package P
2411        package P1
2412                import SI = NameTests.ImportTest7.P.SIunits;
2413        model M
2414                  SI.Resistance R(start=1);
2415                end M;
2416        end P1;
2417       
2418    package SIunits
2419        type Resistance = Real(unit="Ohm");
2420    end SIunits;
2421 
2422  end P;
2423
2424  P.P1.M m;
2425
2426
2427        annotation(__JModelica(UnitTesting(tests={
2428                FlatteningTestCase(
2429                        name="ImportTest7",
2430                        description="Test name lookup in a more complex case",
2431                        flatModel="
2432fclass NameTests.ImportTest7
2433 NameTests.ImportTest7.P.SIunits.Resistance m.R(start = 1);
2434
2435public
2436 type NameTests.ImportTest7.P.SIunits.Resistance = Real(unit = \"Ohm\");
2437end NameTests.ImportTest7;
2438")})));
2439end ImportTest7;
2440
2441model ImportTest9
2442        import Math = Modelica.Math;
2443        parameter Real p1 = Math.cos(9);
2444        parameter Real p2 = Modelica.Math.sin(9);
2445        parameter Real p3 = sqrt(3);
2446
2447        annotation(__JModelica(UnitTesting(tests={
2448                FlatteningTestCase(
2449                        name="ImportTest9",
2450                        description="Test of import of builtin mathematical functions.",
2451                        flatModel="
2452 fclass NameTests.ImportTest9
2453  parameter Real p1 = cos(9) /* -0.9111302618846769 */;
2454  parameter Real p2 = sin(9) /* 0.4121184852417566 */;
2455  parameter Real p3 = sqrt(3) /* 1.7320508075688772 */;
2456 end NameTests.ImportTest9;
2457 ")})));
2458end ImportTest9;
2459
2460
2461model ImportTest10
2462        model A
2463                import C = Modelica.Constants;
2464                Real x = C.pi;
2465        end A;
2466       
2467        A y;
2468
2469        annotation(__JModelica(UnitTesting(tests={
2470                FlatteningTestCase(
2471                        name="ImportTest10",
2472                        description="Using constant from imported package.",
2473                        flatModel="
2474fclass NameTests.ImportTest10
2475 Real y.x = 3.141592653589793;
2476
2477end NameTests.ImportTest10;
2478")})));
2479end ImportTest10;
2480
2481model ImportTest11
2482  import mue_0 = Modelica.Constants.mue_0; 
2483  import SI = Modelica.SIunits;
2484  model M
2485    SI.Voltage v = 0;
2486    Real x = mue_0;
2487  end M;
2488  M m;
2489
2490        annotation(__JModelica(UnitTesting(tests={
2491                FlatteningTestCase(
2492                        name="ImportTest11",
2493                        description="Using constant from imported package.",
2494                        flatModel="
2495fclass NameTests.ImportTest11
2496 Modelica.SIunits.ElectricPotential m.v = 0;
2497 Real m.x = 1.2566370614359173E-6;
2498
2499public
2500 type Modelica.SIunits.ElectricPotential = Real(final quantity = \"ElectricPotential\",final unit = \"V\");
2501end NameTests.ImportTest11;
2502")})));
2503end ImportTest11;
2504
2505
2506model ImportTest12
2507    import SI = NotHere.SI;
2508    SI.Voltage v = 0;
2509
2510    annotation(__JModelica(UnitTesting(tests={
2511        ErrorTestCase(
2512            name="ImportTest12",
2513            description="Check that error is generated properly for missing import",
2514            errorMessage="
25152 errors found:
2516
2517Error at line 2, column 17, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
2518  Cannot find class declaration for NotHere
2519
2520Error at line 3, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
2521  Cannot find class declaration for SI
2522")})));
2523end ImportTest12;
2524
2525
2526model ImportTest13
2527    package P1
2528        constant Real c = 3;
2529        type T = Real;
2530    end P1;
2531   
2532    package P2
2533        extends P1;
2534    end P2;
2535   
2536    import NameTests.ImportTest13.P2.T;
2537    import NameTests.ImportTest13.P2.c;
2538    T t = c;
2539    annotation(__JModelica(UnitTesting(tests={
2540        FlatteningTestCase(
2541            name="ImportTest13",
2542            description="Importing inherited elements",
2543            flatModel="
2544fclass NameTests.ImportTest13
2545 Real t = 3.0;
2546end NameTests.ImportTest13;
2547")})));
2548end ImportTest13;
2549
2550
2551model ShortClassDeclTest1
2552  model A
2553    Real x=2;
2554  end A;
2555 
2556  model AA = A;
2557 
2558  AA aa;
2559
2560
2561        annotation(__JModelica(UnitTesting(tests={
2562                FlatteningTestCase(
2563                        name="ShortClassDeclTest1",
2564                        description="Test simple use of short class declaration.",
2565                        flatModel="
2566fclass NameTests.ShortClassDeclTest1
2567 Real aa.x=2;
2568end NameTests.ShortClassDeclTest1;
2569")})));
2570end ShortClassDeclTest1;
2571
2572
2573
2574model ShortClassDeclTest2
2575  model A
2576    Real x=2;
2577  end A;
2578 
2579  model AA = A;
2580
2581  model AAA = AA;
2582 
2583  AAA aa;
2584
2585
2586        annotation(__JModelica(UnitTesting(tests={
2587                FlatteningTestCase(
2588                        name="ShortClassDeclTest2",
2589                        description="Test simple use of multiple short class declaration.",
2590                        flatModel="
2591fclass NameTests.ShortClassDeclTest2
2592 Real aa.x=2;
2593end NameTests.ShortClassDeclTest2;
2594")})));
2595end ShortClassDeclTest2;
2596
2597model ShortClassDeclTest3
2598  type MyReal = Real(min=-3);
2599  MyReal x(start=3);
2600
2601
2602        annotation(__JModelica(UnitTesting(tests={
2603                FlatteningTestCase(
2604                        name="ShortClassDeclTest3",
2605                        description="Short class declaration of Real",
2606                        flatModel="
2607fclass NameTests.ShortClassDeclTest3
2608 NameTests.ShortClassDeclTest3.MyReal x(start = 3);
2609
2610public
2611 type NameTests.ShortClassDeclTest3.MyReal = Real(min = - 3);
2612end NameTests.ShortClassDeclTest3;
2613")})));
2614end ShortClassDeclTest3;
2615
2616model ShortClassDeclTest31
2617  Modelica.SIunits.Angle x(start=3);
2618
2619
2620        annotation(__JModelica(UnitTesting(tests={
2621                FlatteningTestCase(
2622                        name="ShortClassDeclTest31",
2623                        description="Short class declaration of Real",
2624                        flatModel="
2625fclass NameTests.ShortClassDeclTest31
2626 Modelica.SIunits.Angle x(start = 3);
2627
2628public
2629 type Modelica.SIunits.Angle = Real(final quantity = \"Angle\",final unit = \"rad\",displayUnit = \"deg\");
2630end NameTests.ShortClassDeclTest31;
2631")})));
2632end ShortClassDeclTest31;
2633
2634
2635model ShortClassDeclTest35_Err
2636  type MyReal = Real(min=-3,q=4);
2637  MyReal x(start=3,t=5);
2638
2639
2640    annotation(__JModelica(UnitTesting(tests={
2641        ErrorTestCase(
2642            name="ShortClassDeclTest35_Err",
2643            description="Short class declaration of Real.",
2644            errorMessage="
26452 errors found:
2646
2647Error at line 2, column 29, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
2648In component x:
2649  Cannot find component declaration for q
2650
2651Error at line 3, column 20, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
2652  Cannot find component declaration for t
2653")})));
2654end ShortClassDeclTest35_Err;
2655
2656
2657model ShortClassDeclTest4
2658connector MyRealInput = input MyRealSignal(max=5) "'input Real' as connector";
2659 
2660connector MyRealSignal
2661  "Real port (both input/output possible)" 
2662  replaceable type SignalType = Real(unit="V");
2663 
2664  extends SignalType(nominal=34);
2665 
2666end MyRealSignal;
2667 
2668  MyRealInput u(min=3);
2669 
2670
2671        annotation(__JModelica(UnitTesting(tests={
2672                FlatteningTestCase(
2673                        name="ShortClassDeclTest4",
2674                        description="Test short class declarations and inheritance from primitive types",
2675                        flatModel="
2676fclass NameTests.ShortClassDeclTest4
2677 input NameTests.ShortClassDeclTest4.MyRealInput u(min = 3);
2678
2679public
2680 type NameTests.ShortClassDeclTest4.MyRealInput = Real(max = 5,nominal = 34,unit = \"V\");
2681end NameTests.ShortClassDeclTest4;
2682")})));
2683end ShortClassDeclTest4;
2684
2685model ShortClassDeclTest5
2686connector MyRealInput = input MyRealSignal(start=3,nominal=3) "'input Real' as connector";
2687 
2688 type MyReal = Real(unit="V");
2689 
2690connector MyRealSignal
2691  "Real port (both input/output possible)" 
2692  replaceable type SignalType = MyReal(min=1,max=1,start=1,nominal=1);
2693 
2694  extends SignalType(max=2,start=2,nominal=2);
2695 
2696end MyRealSignal;
2697 
2698  MyRealInput u(nominal=4);
2699 
2700
2701        annotation(__JModelica(UnitTesting(tests={
2702                FlatteningTestCase(
2703                        name="ShortClassDeclTest5",
2704                        description="Test short class declarations and inheritance from primitive types",
2705                        flatModel="
2706fclass NameTests.ShortClassDeclTest5
2707 input NameTests.ShortClassDeclTest5.MyRealInput u(nominal = 4);
2708
2709public
2710 type NameTests.ShortClassDeclTest5.MyRealInput = Real(start = 3,nominal = 3,max = 2,min = 1,unit = \"V\");
2711end NameTests.ShortClassDeclTest5;
2712")})));
2713end ShortClassDeclTest5;
2714
2715
2716model ShortClassDeclTest6
2717model Resistor
2718        parameter Real R;
2719end Resistor;
2720
2721        parameter Real R=1;
2722       
2723        replaceable model Load=Resistor(R=R);
2724        // Correct, sets the R in Resistor to R from model A.
2725/*
2726        replaceable model LoadError
2727                extends Resistor(R=R);
2728                // Gives the singular equation R=R, since the right-hand side R
2729                // is searched for in LoadError and found in its base-class Resistor.
2730        end LoadError constrainedby TwoPin;
2731*/     
2732        Load a;
2733       
2734
2735        annotation(__JModelica(UnitTesting(tests={
2736                FlatteningTestCase(
2737                        name="ShortClassDeclTest6",
2738                        description="Test short class declarations.",
2739                        flatModel="
2740fclass NameTests.ShortClassDeclTest6
2741 parameter Real R = 1;
2742 parameter Real a.R = R /*(0.0)*/;
2743
2744end NameTests.ShortClassDeclTest6;
2745")})));
2746end ShortClassDeclTest6;
2747
2748
2749// TODO: These errors should be covered by a "Check for errors" that should
2750//       be separate from the error check done when instantiating
2751//model ShortClassDeclTest7_Err
2752//  model A
2753//    Real x = 2;
2754//  end A;
2755// 
2756//  model B = A(y = 2.5);
2757// 
2758//  B b(x = 3);
2759//
2760//      annotation(__JModelica(UnitTesting(tests={
2761//              ErrorTestCase(
2762//                      name="ShortClassDeclTest7_Err",
2763//                      description="Short class declaration of Real.",
2764//                      errorMessage="
2765//1 errors found:
2766//Error: in file 'src/test/modelica/NameTests.mo':
2767//Semantic error at line 834, column 14:
2768//  Cannot find component declaration for y
2769//")})));
2770//end ShortClassDeclTest7_Err;
2771//
2772//
2773//model ShortClassDeclTest75_Err
2774//  model A
2775//    Real x = 2;
2776//  end A;
2777// 
2778//  model B = A(y = 2.5);
2779// 
2780//  model C = B;
2781// 
2782//  model D
2783//        extends B;
2784//  end D;
2785// 
2786//  B b(x = 3);
2787//
2788//      annotation(__JModelica(UnitTesting(tests={
2789//              ErrorTestCase(
2790//                      name="ShortClassDeclTest75_Err",
2791//                      description="",
2792//                      errorMessage="
2793//1 errors found:
2794//Error: in file 'Compiler/ModelicaFrontEnd/src/test/modelica/NameTests.mo':
2795//Semantic error at line 2625, column 15:
2796//  Cannot find component declaration for y
2797//")})));
2798//end ShortClassDeclTest75_Err;
2799
2800
2801model ShortClassDeclTest8
2802 connector RealInput = input Real;
2803
2804 RealInput u;
2805 Modelica.Blocks.Interfaces.RealInput u2;
2806
2807
2808        annotation(__JModelica(UnitTesting(tests={
2809                FlatteningTestCase(
2810                        name="ShortClassDeclTest8",
2811                        description="Test short class declarations",
2812                        flatModel="
2813fclass NameTests.ShortClassDeclTest8
2814 input NameTests.ShortClassDeclTest8.RealInput u;
2815 input Modelica.Blocks.Interfaces.RealInput u2;
2816
2817public
2818 type NameTests.ShortClassDeclTest8.RealInput = Real;
2819 type Modelica.Blocks.Interfaces.RealInput = Real;
2820end NameTests.ShortClassDeclTest8;
2821")})));
2822end ShortClassDeclTest8;
2823
2824
2825model ShortClassDeclTest9
2826    package B = A1;
2827   
2828    package A2
2829        function f
2830            output Real x = 1;
2831        algorithm
2832        end f;
2833    end A2;
2834   
2835    Real y = B.f();
2836end ShortClassDeclTest9;
2837
2838
2839
2840model DerTest1
2841        Real x;
2842equation
2843    der(x)=1;
2844end DerTest1;
2845
2846model InitialEquationTest1
2847 
2848  Real x;
2849  initial equation
2850  x = 1;
2851  equation
2852  der(x)=1;
2853 
2854end InitialEquationTest1;
2855
2856model EndExpTest1
2857 Real x[1];
2858equation
2859 x[end] = 2;
2860
2861
2862        annotation(__JModelica(UnitTesting(tests={
2863                FlatteningTestCase(
2864                        name="EndExpTest1",
2865                        description="Test of end expression",
2866                        flatModel="
2867fclass NameTests.EndExpTest1
2868 Real x[1];
2869equation 
2870 x[1] = 2;
2871
2872end NameTests.EndExpTest1;
2873")})));
2874end EndExpTest1;
2875
2876model ForTest1
2877  Real x[3,3];
2878equation
2879  for i in 1:3, j in 1:3 loop
2880    x[i,j] = i + j;
2881  end for;
2882
2883        annotation(__JModelica(UnitTesting(tests={
2884                FlatteningTestCase(
2885                        name="ForTest1",
2886                        description="Test for equations.",
2887                        flatModel="
2888fclass NameTests.ForTest1
2889 Real x[3,3];
2890equation 
2891 x[1,1] = 1 + 1;
2892 x[1,2] = 1 + 2;
2893 x[1,3] = 1 + 3;
2894 x[2,1] = 2 + 1;
2895 x[2,2] = 2 + 2;
2896 x[2,3] = 2 + 3;
2897 x[3,1] = 3 + 1;
2898 x[3,2] = 3 + 2;
2899 x[3,3] = 3 + 3;
2900
2901end NameTests.ForTest1;
2902")})));
2903end ForTest1;
2904
2905
2906model ForTest2_Err
2907
2908  Real x[3,3];
2909equation
2910  for i in 1:3, j in 1:3 loop
2911    x[i,j] = i + k;
2912  end for;
2913
2914    annotation(__JModelica(UnitTesting(tests={
2915        ErrorTestCase(
2916            name="ForTest2_Err",
2917            description="Test for equations.",
2918            errorMessage="
29191 errors found:
2920
2921Error at line 6, column 18, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
2922  Cannot find class or component declaration for k
2923")})));
2924end ForTest2_Err;
2925
2926model StateSelectTest
2927 Real x(stateSelect=StateSelect.never);
2928 Real y(stateSelect=StateSelect.avoid);
2929 Real z(stateSelect=StateSelect.default);
2930 Real w(stateSelect=StateSelect.prefer);
2931 Real v(stateSelect=StateSelect.always);
2932equation
2933 x = 2;
2934 y = 1;
2935 der(z) = 1;
2936 der(w) = 1;
2937 der(v) = 1;
2938
2939        annotation(__JModelica(UnitTesting(tests={
2940                FlatteningTestCase(
2941                        name="StateSelectTest",
2942                        description="Test for equations.",
2943                        flatModel="
2944fclass NameTests.StateSelectTest
2945 Real x(stateSelect = StateSelect.never);
2946 Real y(stateSelect = StateSelect.avoid);
2947 Real z(stateSelect = StateSelect.default);
2948 Real w(stateSelect = StateSelect.prefer);
2949 Real v(stateSelect = StateSelect.always);
2950equation
2951 x = 2;
2952 y = 1;
2953 der(z) = 1;
2954 der(w) = 1;
2955 der(v) = 1;
2956
2957public
2958 type StateSelect = enumeration(never \"Do not use as state at all.\", avoid \"Use as state, if it cannot be avoided (but only if variable appears differentiated and no other potential state with attribute default, prefer, or always can be selected).\", default \"Use as state if appropriate, but only if variable appears differentiated.\", prefer \"Prefer it as state over those having the default value (also variables can be selected, which do not appear differentiated).\", always \"Do use it as a state.\");
2959
2960end NameTests.StateSelectTest;
2961")})));
2962end StateSelectTest;
2963
2964
2965
2966model IndexLookup1
2967  model B
2968    Real z[2] = {1, 2};
2969  end B;
2970
2971  parameter Integer i = 2;
2972  B y;
2973  Real x = y.z[i];
2974
2975        annotation(__JModelica(UnitTesting(tests={
2976                FlatteningTestCase(
2977                        name="IndexLookup1",
2978                        description="Name lookup from within array subscript",
2979                        flatModel="
2980fclass NameTests.IndexLookup1
2981 parameter Integer i = 2 /* 2 */;
2982 Real y.z[2] = {1, 2};
2983 Real x = (y.z[1:2])[i];
2984
2985end NameTests.IndexLookup1;
2986")})));
2987end IndexLookup1;
2988
2989
2990model IndexLookup2
2991  model B
2992    parameter Integer i = 1;
2993    Real z[2] = {1, 2};
2994  end B;
2995
2996  parameter Integer i = 2;
2997  B y;
2998  Real x = y.z[i];
2999
3000        annotation(__JModelica(UnitTesting(tests={
3001                FlatteningTestCase(
3002                        name="IndexLookup2",
3003                        description="Name lookup from within array subscript",
3004                        flatModel="
3005fclass NameTests.IndexLookup2
3006 parameter Integer i = 2 /* 2 */;
3007 parameter Integer y.i = 1 /* 1 */;
3008 Real y.z[2] = {1, 2};
3009 Real x = (y.z[1:2])[i];
3010
3011end NameTests.IndexLookup2;
3012")})));
3013end IndexLookup2;
3014
3015model ConditionalComponentTest1_Err
3016  parameter Real x = 1 if 1;
3017
3018annotation(__JModelica(UnitTesting(tests={
3019    ErrorTestCase(
3020        name="ConditionalComponentTest1_Err",
3021        description="Test of type checking of conditional components.",
3022        errorMessage="
3023
3024
3025Error at line 2, column 3, in file '...', NON_BOOLEAN_CONDITIONAL_GUARD:
3026  The guard expression of a conditional component should be a scalar Boolean expression
3027")})));
3028end ConditionalComponentTest1_Err;
3029
3030model ConditionalComponentTest2_Err
3031  parameter Boolean b[2] = {true,true};
3032  parameter Real x = 1 if b;
3033
3034annotation(__JModelica(UnitTesting(tests={
3035    ErrorTestCase(
3036        name="ConditionalComponentTest2_Err",
3037        description="Test of type checking of conditional components.",
3038        errorMessage="
3039
3040
3041Error at line 3, column 3, in file '...', NON_BOOLEAN_CONDITIONAL_GUARD:
3042  The guard expression of a conditional component should be a scalar Boolean expression
3043")})));
3044end ConditionalComponentTest2_Err;
3045
3046model ConditionalComponentTest3_Err
3047  parameter Integer b[2] = {1,1};
3048  parameter Real x = 1 if b;
3049
3050annotation(__JModelica(UnitTesting(tests={
3051    ErrorTestCase(
3052        name="ConditionalComponentTest3_Err",
3053        description="Test of type checking of conditional components.",
3054        errorMessage="
3055
3056
3057Error at line 3, column 3, in file '...', NON_BOOLEAN_CONDITIONAL_GUARD:
3058  The guard expression of a conditional component should be a scalar Boolean expression
3059")})));
3060end ConditionalComponentTest3_Err;
3061
3062
3063model ConditionalComponentTest4
3064  parameter Boolean b = true;
3065  parameter Real x = 1 if b;
3066
3067        annotation(__JModelica(UnitTesting(tests={
3068                FlatteningTestCase(
3069                        name="ConditionalComponentTest4",
3070                        description="Test flattening of conditional components.",
3071                        flatModel="
3072fclass NameTests.ConditionalComponentTest4
3073 structural parameter Boolean b = true /* true */;
3074 parameter Real x = 1 /* 1 */;
3075
3076end NameTests.ConditionalComponentTest4;
3077")})));
3078end ConditionalComponentTest4;
3079
3080
3081model ConditionalComponentTest5
3082  package P
3083    constant Boolean b = true;
3084  end P;
3085  parameter Real x = 1 if P.b;
3086
3087        annotation(__JModelica(UnitTesting(tests={
3088                FlatteningTestCase(
3089                        name="ConditionalComponentTest5",
3090                        description="Test flattening of conditional components.",
3091                        flatModel="
3092fclass NameTests.ConditionalComponentTest5
3093 parameter Real x = 1 /* 1 */;
3094
3095end NameTests.ConditionalComponentTest5;
3096")})));
3097end ConditionalComponentTest5;
3098
3099model ConditionalComponentTest6_Err
3100  parameter Boolean b = false;
3101  parameter Real x = 1 if b;
3102  Real y = x; 
3103
3104    annotation(__JModelica(UnitTesting(tests={
3105        ErrorTestCase(
3106            name="ConditionalComponentTest6_Err",
3107            description="Test of type checking of conditional components.",
3108            errorMessage="
31091 errors found:
3110
3111Error at line 4, column 12, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3112  The component x is conditional: Access of conditional components is only valid in connect statements
3113")})));
3114end ConditionalComponentTest6_Err;
3115
3116model ConditionalComponentTest7_Err
3117  model M
3118    Real x = 2;
3119  end M;
3120  parameter Boolean b = false;
3121  M m if b;
3122  Real y = m.x; 
3123
3124    annotation(__JModelica(UnitTesting(tests={
3125        ErrorTestCase(
3126            name="ConditionalComponentTest7_Err",
3127            description="Test of type checking of conditional components.",
3128            errorMessage="
31291 errors found:
3130
3131Error at line 7, column 12, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3132  The component m is conditional: Access of conditional components is only valid in connect statements
3133")})));
3134end ConditionalComponentTest7_Err;
3135
3136model ConditionalComponentTest8
3137  parameter Boolean b = false;
3138  parameter Real x = 1 if b;
3139
3140        annotation(__JModelica(UnitTesting(tests={
3141                FlatteningTestCase(
3142                        name="ConditionalComponentTest8",
3143                        description="Test flattening of conditional components.",
3144                        flatModel="
3145fclass NameTests.ConditionalComponentTest8
3146 structural parameter Boolean b = false /* false */;
3147
3148end NameTests.ConditionalComponentTest8;
3149")})));
3150end ConditionalComponentTest8;
3151
3152model ConditionalComponentTest9
3153  model N
3154   Real z;
3155   equation
3156   z^2 = 4;
3157  end N;
3158
3159  model M
3160    Real x;
3161    N n;
3162    extends N;
3163    equation
3164    x = 3;
3165  end M;
3166
3167  parameter Boolean b = false;
3168  M m if b;
3169
3170
3171        annotation(__JModelica(UnitTesting(tests={
3172                FlatteningTestCase(
3173                        name="ConditionalComponentTest9",
3174                        description="Test flattening of conditional components.",
3175                        flatModel="
3176fclass NameTests.ConditionalComponentTest9
3177 structural parameter Boolean b = false /* false */;
3178
3179end NameTests.ConditionalComponentTest9;
3180")})));
3181end ConditionalComponentTest9;
3182
3183model ConditionalComponentTest10
3184  connector RealInput = input Real;
3185  connector RealOutput = output Real;
3186
3187  model Source
3188    RealOutput y = p;
3189    parameter Real p = 1;
3190  end Source;
3191
3192  model Sink
3193    RealInput u;
3194  end Sink;
3195
3196  model M
3197    parameter Boolean b = true;
3198    RealInput u1 if b;
3199    RealInput u2 if not b;
3200    RealOutput y;
3201  equation
3202    connect(u1,y);
3203    connect(u2,y);
3204  end M;
3205
3206  parameter Boolean b = true;
3207  M m(b=b);
3208  Source source1 if b;
3209  Source source2 if not b;
3210  Sink sink;
3211  equation
3212  connect(source1.y,m.u1);
3213  connect(source2.y,m.u2);
3214  connect(m.y,sink.u);
3215
3216
3217        annotation(__JModelica(UnitTesting(tests={
3218                FlatteningTestCase(
3219                        name="ConditionalComponentTest10",
3220                        description="Test flattening of conditional components",
3221                        flatModel="
3222fclass NameTests.ConditionalComponentTest10
3223 structural parameter Boolean b = true /* true */;
3224 structural parameter Boolean m.b = true /* true */;
3225 NameTests.ConditionalComponentTest10.RealInput m.u1;
3226 NameTests.ConditionalComponentTest10.RealOutput m.y;
3227 NameTests.ConditionalComponentTest10.RealOutput source1.y = source1.p;
3228 parameter Real source1.p = 1 /* 1 */;
3229 NameTests.ConditionalComponentTest10.RealInput sink.u;
3230equation
3231 m.u1 = source1.y;
3232 m.y = sink.u;
3233 m.u1 = m.y;
3234
3235public
3236 type NameTests.ConditionalComponentTest10.RealInput = Real;
3237 type NameTests.ConditionalComponentTest10.RealOutput = Real;
3238end NameTests.ConditionalComponentTest10;
3239")})));
3240end ConditionalComponentTest10;
3241
3242model ConditionalComponentTest11
3243  connector RealInput = input Real;
3244  connector RealOutput = output Real;
3245
3246  model Source
3247    RealOutput y = p;
3248    parameter Real p = 1;
3249  end Source;
3250
3251  model Sink
3252    RealInput u;
3253  end Sink;
3254
3255  model M
3256    parameter Boolean b = true;
3257    RealInput u1 if b;
3258    RealInput u2 if not b;
3259    RealOutput y;
3260  equation
3261    connect(u1,y);
3262    connect(u2,y);
3263  end M;
3264
3265  parameter Boolean b = false;
3266  M m(b=b);
3267  Source source1 if b;
3268  Source source2 if not b;
3269  Sink sink;
3270  equation
3271  connect(source1.y,m.u1);
3272  connect(source2.y,m.u2);
3273  connect(m.y,sink.u);
3274
3275
3276        annotation(__JModelica(UnitTesting(tests={
3277                FlatteningTestCase(
3278                        name="ConditionalComponentTest11",
3279                        description="Test flattening of conditional components",
3280                        flatModel="
3281fclass NameTests.ConditionalComponentTest11
3282 structural parameter Boolean b = false /* false */;
3283 structural parameter Boolean m.b = false /* false */;
3284 NameTests.ConditionalComponentTest11.RealInput m.u2;
3285 NameTests.ConditionalComponentTest11.RealOutput m.y;
3286 NameTests.ConditionalComponentTest11.RealOutput source2.y = source2.p;
3287 parameter Real source2.p = 1 /* 1 */;
3288 NameTests.ConditionalComponentTest11.RealInput sink.u;
3289equation
3290 m.u2 = source2.y;
3291 m.y = sink.u;
3292 m.u2 = m.y;
3293
3294public
3295 type NameTests.ConditionalComponentTest11.RealInput = Real;
3296 type NameTests.ConditionalComponentTest11.RealOutput = Real;
3297end NameTests.ConditionalComponentTest11;
3298")})));
3299end ConditionalComponentTest11;
3300
3301
3302model ConditionalComponentTest12
3303        model A
3304                parameter Boolean flag = true;
3305                B b1 if flag;
3306                B b2 if not flag;
3307                Real z1 if flag;
3308                Real z2 if not flag;
3309        end A;
3310       
3311        model B
3312                Real x;
3313        end B;
3314       
3315        Real y = 1;
3316        A a(b1(x = y), b2(x = y), z1 = y, z2 = y);
3317
3318        annotation(__JModelica(UnitTesting(tests={
3319                FlatteningTestCase(
3320                        name="ConditionalComponentTest12",
3321                        description="Modifying conditional component",
3322                        flatModel="
3323fclass NameTests.ConditionalComponentTest12
3324 Real y = 1;
3325 structural parameter Boolean a.flag = true /* true */;
3326 Real a.b1.x = y;
3327 Real a.z1 = y;
3328end NameTests.ConditionalComponentTest12;
3329")})));
3330end ConditionalComponentTest12;
3331
3332
3333model ConditionalComponentTest13_Err
3334        model A
3335                Real x;
3336        end A;
3337       
3338        model B
3339        parameter Boolean flag = true;
3340        A a1 if flag;
3341        A a2 if not flag;
3342        end B;
3343       
3344    Real y1 if b.flag;
3345    Real y2 if not b.flag;
3346        B b(a1(x = y1), a2(x = y2));
3347
3348    annotation(__JModelica(UnitTesting(tests={
3349        ErrorTestCase(
3350            name="ConditionalComponentTest13_Err",
3351            description="Using value of conditional component in modification for other conditional component",
3352            errorMessage="
33532 errors found:
3354
3355Error at line 14, column 13, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3356  The component y1 is conditional: Access of conditional components is only valid in connect statements
3357
3358Error at line 14, column 25, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3359  The component y2 is conditional: Access of conditional components is only valid in connect statements
3360")})));
3361end ConditionalComponentTest13_Err;
3362
3363model ConditionalComponentTest14
3364    record R
3365        parameter Real x;
3366    end R;
3367   
3368    parameter R r if false;
3369
3370    annotation(__JModelica(UnitTesting(tests={
3371        FlatteningTestCase(
3372            name="ConditionalComponentTest14",
3373            description="Flattening type of conditional component",
3374            flatModel="
3375fclass NameTests.ConditionalComponentTest14
3376end NameTests.ConditionalComponentTest14;
3377")})));
3378end ConditionalComponentTest14;
3379
3380
3381model ConditionalComponentTest15_Err
3382    connector C
3383        Real x;
3384    end C;
3385   
3386    parameter Integer b[2] = {1,1};
3387    C c if b;
3388annotation(__JModelica(UnitTesting(tests={
3389    ErrorTestCase(
3390        name="ConditionalComponentTest15_Err",
3391        description="Test of type checking of conditional composite component.",
3392        errorMessage="
3393
3394
3395Error at line 7, column 5, in file '...', NON_BOOLEAN_CONDITIONAL_GUARD:
3396  The guard expression of a conditional component should be a scalar Boolean expression
3397")})));
3398end ConditionalComponentTest15_Err;
3399
3400
3401model ConditionalComponentTest16
3402    connector C
3403        Real x;
3404    end C;
3405   
3406    parameter Boolean b = false;
3407    C c if b;
3408annotation(__JModelica(UnitTesting(tests={
3409    FlatteningTestCase(
3410        description="Flattening conditional composite component",
3411        flatModel="
3412fclass NameTests.ConditionalComponentTest16
3413 structural parameter Boolean b = false /* false */;
3414end NameTests.ConditionalComponentTest16;
3415")})));
3416end ConditionalComponentTest16;
3417
3418
3419model ConditionalComponentTest17
3420    connector C
3421        Real x;
3422    end C;
3423   
3424    parameter Boolean b = true;
3425    C c if b;
3426annotation(__JModelica(UnitTesting(tests={
3427    FlatteningTestCase(
3428        description="Flattening conditional composite component",
3429        flatModel="
3430fclass NameTests.ConditionalComponentTest17
3431 structural parameter Boolean b = true /* true */;
3432 potential Real c.x;
3433end NameTests.ConditionalComponentTest17;
3434")})));
3435end ConditionalComponentTest17;
3436
3437
3438
3439model AttributeDot1
3440  Real x=1;
3441  parameter Real p = x.start;
3442
3443    annotation(__JModelica(UnitTesting(tests={
3444        ErrorTestCase(
3445            name="AttributeDot1",
3446            description="Access to attribute with dot notation",
3447            errorMessage="
34481 errors found:
3449
3450Error at line 3, column 22, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3451  Can not access attribute of primitive with dot notation: x.start
3452")})));
3453end AttributeDot1;
3454
3455
3456
3457model ComplexExpInDer1
3458 Real x;
3459 Real y;
3460equation
3461 der(x * y) = 0;
3462
3463        annotation(__JModelica(UnitTesting(tests={
3464                FlatteningTestCase(
3465                        name="ComplexExpInDer1",
3466                        description="",
3467                        flatModel="
3468fclass NameTests.ComplexExpInDer1
3469 Real x;
3470 Real y;
3471equation
3472 x * der(y) + der(x) * y = 0;
3473end NameTests.ComplexExpInDer1;
3474")})));
3475end ComplexExpInDer1;
3476
3477
3478model ComplexExpInDer2
3479 Real x;
3480 Real y;
3481equation
3482 der(der(x + 1) - y) = 0;
3483
3484        annotation(__JModelica(UnitTesting(tests={
3485                FlatteningTestCase(
3486                        name="ComplexExpInDer2",
3487                        description="",
3488                        flatModel="
3489fclass NameTests.ComplexExpInDer2
3490 Real x;
3491 Real y;
3492equation
3493 der(x,2) - der(y) = 0;
3494end NameTests.ComplexExpInDer2;
3495")})));
3496end ComplexExpInDer2;
3497
3498
3499model ComplexExpInDer3
3500 Real x;
3501 Real y;
3502equation
3503 der({x, y}) = zeros(2);
3504
3505        annotation(__JModelica(UnitTesting(tests={
3506                FlatteningTestCase(
3507                        name="ComplexExpInDer3",
3508                        description="",
3509                        flatModel="
3510fclass NameTests.ComplexExpInDer3
3511 Real x;
3512 Real y;
3513equation
3514 {der(x),der(y)} = zeros(2);
3515end NameTests.ComplexExpInDer3;
3516")})));
3517end ComplexExpInDer3;
3518
3519model EmptyAnnotationTest
3520 
3521  model M
3522  annotation();
3523  end M;
3524  M m;
3525        annotation(__JModelica(UnitTesting(tests={
3526                FlatteningTestCase(
3527                        name="EmptyAnnotationTest",
3528                        description="Test that it is ok to have an empty annotation.",
3529                        flatModel="
3530fclass NameTests.EmptyAnnotationTest
3531end NameTests.EmptyAnnotationTest;
3532")})));
3533end EmptyAnnotationTest;
3534
3535model EmptyModificationTest
3536 
3537  model M
3538  Real x()=1;
3539  end M;
3540  M m;
3541        annotation(__JModelica(UnitTesting(tests={
3542                FlatteningTestCase(
3543                        name="EmptyModificationTest",
3544                        description="Test that it is ok to have an empty modification.",
3545                        flatModel="
3546fclass NameTests.EmptyModificationTest
3547 Real m.x = 1;
3548end NameTests.EmptyModificationTest;
3549")})));
3550end EmptyModificationTest;
3551
3552model FunctionCallLeftTest
3553  function f
3554   input Real x1;
3555   output Real y1;
3556  algorithm
3557   y1:=2*x1;
3558  end f;
3559 
3560   Real x;
3561  algorithm
3562   (x) := f(1);
3563       
3564        annotation(__JModelica(UnitTesting(tests={
3565                FlatteningTestCase(
3566                        name="FunctionCallLeftTest",
3567                        description="Test so that it is ok to have only one output argument in a function call left statement.",
3568                        flatModel="
3569fclass NameTests.FunctionCallLeftTest
3570 Real x;
3571algorithm
3572 (x) := NameTests.FunctionCallLeftTest.f(1);
3573
3574public
3575 function NameTests.FunctionCallLeftTest.f
3576  input Real x1;
3577  output Real y1;
3578 algorithm
3579  y1 := 2 * x1;
3580  return;
3581 end NameTests.FunctionCallLeftTest.f;
3582
3583end NameTests.FunctionCallLeftTest;
3584")})));
3585end FunctionCallLeftTest;
3586
3587
3588model PreAliasTest1
3589        discrete Real x;
3590        discrete Real y;
3591initial equation
3592        pre(x) = 42;
3593equation
3594        x = y;
3595        x = pre(x) * pre(y) + 3.14;
3596
3597        annotation(__JModelica(UnitTesting(tests={
3598                TransformCanonicalTestCase(
3599                        name="PreAliasTest1",
3600                        description="Test so that pre() variables are rewritten correctly",
3601                        flatModel="
3602fclass NameTests.PreAliasTest1
3603 discrete Real x;
3604initial equation 
3605 pre(x) = 42;
3606equation
3607 x = pre(x) * pre(x) + 3.14;
3608end NameTests.PreAliasTest1;
3609")})));
3610end PreAliasTest1;
3611
3612
3613model AssignedInWhenRecursion
3614    model A
3615        parameter Boolean x = true;
3616    end A;
3617   
3618    model B
3619        Real y = 2;
3620    end B;
3621   
3622    parameter Integer n = if a.x then 2 else 3;
3623    A a;
3624    B b[n];
3625end AssignedInWhenRecursion;
3626
3627model WhenInExtendsTest
3628        model A
3629                Real x;
3630                Real y;
3631                Integer i;
3632                parameter Boolean b = false;
3633        equation
3634                i = 1;
3635                when initial() then
3636                        if b then
3637                                y = 2 + i;
3638                        else
3639                                y = 4;
3640                        end if;
3641                end when;
3642                when time>=3 then
3643                        x = 3;
3644                end when;
3645        end A;
3646       
3647        model B
3648                extends A;
3649        end B;
3650       
3651        B b;
3652
3653        annotation(__JModelica(UnitTesting(tests={
3654                FlatteningTestCase(
3655                        name="WhenInExtendsTest",
3656                        description="",
3657                        flatModel="
3658fclass NameTests.WhenInExtendsTest
3659 discrete Real b.x;
3660 discrete Real b.y;
3661 discrete Integer b.i;
3662 structural parameter Boolean b.b = false /* false */;
3663equation
3664 b.i = 1;
3665 when initial() then
3666  if false then
3667   b.y = 2 + b.i;
3668  else
3669   b.y = 4;
3670  end if;
3671 end when;
3672 when time >= 3 then
3673  b.x = 3;
3674 end when;
3675end NameTests.WhenInExtendsTest;
3676")})));
3677end WhenInExtendsTest;
3678
3679
3680model InheritInputTest1
3681        connector A
3682                Real x;
3683        end A;
3684       
3685        input A a;
3686
3687        annotation(__JModelica(UnitTesting(tests={
3688                FlatteningTestCase(
3689                        name="InheritInputTest1",
3690                        description="Check that input is propagated to child components",
3691                        flatModel="
3692fclass NameTests.InheritInputTest1
3693 input Real a.x;
3694end NameTests.InheritInputTest1;
3695")})));
3696end InheritInputTest1;
3697
3698
3699model InheritInputTest2
3700    connector A
3701        Real x;
3702    end A;
3703       
3704        connector B
3705                A a;
3706        end B;
3707   
3708    input B b;
3709
3710        annotation(__JModelica(UnitTesting(tests={
3711                FlatteningTestCase(
3712                        name="InheritInputTest2",
3713                        description="Check that input is propagated to child components: nested",
3714                        flatModel="
3715fclass NameTests.InheritInputTest2
3716 input Real b.a.x;
3717end NameTests.InheritInputTest2;
3718")})));
3719end InheritInputTest2;
3720
3721
3722model InheritInputTest3
3723    connector A
3724        input Real x;
3725    end A;
3726   
3727    input A a;
3728
3729    annotation(__JModelica(UnitTesting(tests={
3730        ErrorTestCase(
3731            name="InheritInputTest3",
3732            description="Check that it isn't allowed to declare a component containing an input as input",
3733            errorMessage="
37341 errors found:
3735
3736Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3737  Can't declare x as input, since it contains a component declared as input or output
3738")})));
3739end InheritInputTest3;
3740
3741
3742model InheritInputTest4
3743    connector A
3744        output Real x;
3745    end A;
3746   
3747    input A a;
3748
3749    annotation(__JModelica(UnitTesting(tests={
3750        ErrorTestCase(
3751            name="InheritInputTest4",
3752            description="Check that it isn't allowed to declare a component containing an output as input",
3753            errorMessage="
37541 errors found:
3755
3756Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3757  Can't declare x as output, since it contains a component declared as input or output
3758")})));
3759end InheritInputTest4;
3760
3761
3762model InheritOutputTest1
3763    connector A
3764        Real x;
3765    end A;
3766   
3767    output A a;
3768
3769        annotation(__JModelica(UnitTesting(tests={
3770                FlatteningTestCase(
3771                        name="InheritOutputTest1",
3772                        description="Check that output is propagated to child components",
3773                        flatModel="
3774fclass NameTests.InheritOutputTest1
3775 output Real a.x;
3776end NameTests.InheritOutputTest1;
3777")})));
3778end InheritOutputTest1;
3779
3780
3781model InheritOutputTest2
3782    connector A
3783        Real x;
3784    end A;
3785   
3786    connector B
3787        A a;
3788    end B;
3789   
3790    output B b;
3791
3792        annotation(__JModelica(UnitTesting(tests={
3793                FlatteningTestCase(
3794                        name="InheritOutputTest2",
3795                        description="Check that output is propagated to child components: nested",
3796                        flatModel="
3797fclass NameTests.InheritOutputTest2
3798 output Real b.a.x;
3799end NameTests.InheritOutputTest2;
3800")})));
3801end InheritOutputTest2;
3802
3803
3804model InheritOutputTest3
3805    connector A
3806        output Real x;
3807    end A;
3808   
3809    output A a;
3810
3811    annotation(__JModelica(UnitTesting(tests={
3812        ErrorTestCase(
3813            name="InheritOutputTest3",
3814            description="Check that it isn't allowed to declare a component containing an output as output",
3815            errorMessage="
38161 errors found:
3817
3818Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3819  Can't declare x as output, since it contains a component declared as input or output
3820")})));
3821end InheritOutputTest3;
3822
3823
3824model InheritOutputTest4
3825    connector A
3826        input Real x;
3827    end A;
3828   
3829    output A a;
3830
3831    annotation(__JModelica(UnitTesting(tests={
3832        ErrorTestCase(
3833            name="InheritOutputTest4",
3834            description="Check that it isn't allowed to declare a component containing an input as output",
3835            errorMessage="
38361 errors found:
3837
3838Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3839  Can't declare x as input, since it contains a component declared as input or output
3840")})));
3841end InheritOutputTest4;
3842
3843
3844model InheritFlowTest1
3845    connector A
3846        Real x;
3847    end A;
3848
3849    connector B
3850                A ap;
3851        flow A af;
3852        end B;
3853       
3854        B b1, b2;
3855equation
3856        connect(b1, b2);
3857
3858annotation(__JModelica(UnitTesting(tests={
3859    FlatteningTestCase(
3860        name="InheritFlowTest1",
3861        description="Check that flow is propagated to child components",
3862        flatModel="
3863fclass NameTests.InheritFlowTest1
3864 potential Real b1.ap.x;
3865 flow Real b1.af.x;
3866 potential Real b2.ap.x;
3867 flow Real b2.af.x;
3868equation
3869 - b1.af.x - b2.af.x = 0.0;
3870 b1.ap.x = b2.ap.x;
3871 b1.af.x = 0.0;
3872 b2.af.x = 0.0;
3873end NameTests.InheritFlowTest1;
3874")})));
3875end InheritFlowTest1;
3876
3877
3878model InheritFlowTest2
3879    connector A
3880        flow Real x;
3881    end A;
3882   
3883    flow A a;
3884
3885    annotation(__JModelica(UnitTesting(tests={
3886        ErrorTestCase(
3887            name="InheritFlowTest2",
3888            description="Check that it isn't allowed to declare a component containing an flow as flow",
3889            errorMessage="
38901 errors found:
3891
3892Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3893  Can't declare x as flow, since it contains a component declared as flow
3894")})));
3895end InheritFlowTest2;
3896
3897
3898
3899model DuplicateVariables1
3900    model A
3901      Real x(start=1, min=2) = 3;
3902    end A;
3903    extends A;
3904   
3905    Real x(start=1, min=2) = 3;
3906
3907    annotation(__JModelica(UnitTesting(tests={
3908        FlatteningTestCase(
3909            name="DuplicateVariables1",
3910            description="Test that identical components in base classes are handled correctly",
3911            flatModel="
3912fclass NameTests.DuplicateVariables1
3913 Real x(start = 1,min = 2) = 3;
3914end NameTests.DuplicateVariables1;
3915")})));
3916end DuplicateVariables1;
3917
3918
3919model DuplicateVariables2
3920    model A
3921        Real x;
3922    equation
3923        der(x) = time;
3924    end A;
3925   
3926    model B
3927        A a;
3928    end B;
3929   
3930    extends B;
3931    A a;
3932
3933    annotation(__JModelica(UnitTesting(tests={
3934        FlatteningTestCase(
3935            name="DuplicateVariables2",
3936            description="Test that identical components in base classes are handled correctly",
3937            flatModel="
3938fclass NameTests.DuplicateVariables2
3939 Real a.x;
3940equation
3941 der(a.x) = time;
3942end NameTests.DuplicateVariables2;
3943")})));
3944end DuplicateVariables2;
3945
3946
3947model DuplicateVariables3
3948    Real x;
3949    Real x;
3950
3951    annotation(__JModelica(UnitTesting(tests={
3952        ErrorTestCase(
3953            name="DuplicateVariables3",
3954            description="",
3955            errorMessage="
39561 errors found:
3957
3958Error at line 3, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3959  Duplicate component in same class: Real x
3960")})));
3961end DuplicateVariables3;
3962
3963
3964model DuplicateVariables5
3965    model A
3966      Real x(start=1, min=2) = 3;
3967    end A;
3968   
3969    model B
3970        extends A;
3971        Real x(start=1, min=2) = 3;
3972    end B;
3973   
3974    B b[2];
3975
3976    annotation(__JModelica(UnitTesting(tests={
3977        FlatteningTestCase(
3978            name="DuplicateVariables5",
3979            description="Test that identical components in base classes are handled correctly",
3980            flatModel="
3981fclass NameTests.DuplicateVariables5
3982 Real b[1].x(start = 1,min = 2) = 3;
3983 Real b[2].x(start = 1,min = 2) = 3;
3984end NameTests.DuplicateVariables5;
3985")})));
3986end DuplicateVariables5;
3987
3988
3989model DuplicateVariables6
3990    model A
3991        Real x;
3992        Real x;
3993    end A;
3994   
3995    A a[2];
3996
3997    annotation(__JModelica(UnitTesting(tests={
3998        ErrorTestCase(
3999            name="DuplicateVariables6",
4000            description="",
4001            errorMessage="
40021 errors found:
4003
4004Error at line 4, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
4005In component a:
4006  Duplicate component in same class: Real x
4007")})));
4008end DuplicateVariables6;
4009
4010
4011
4012model BadEscape1
4013        parameter String a = "\qabc\ def\nghi\\xjkl\?mno\#";
4014
4015    annotation(__JModelica(UnitTesting(tests={
4016        ErrorTestCase(
4017            name="BadEscape1",
4018            description="Illegal escape sequences in string",
4019            errorMessage="
40203 errors found:
4021
4022Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4023  Illegal escape sequence at position 1 in string: '\\q'
4024
4025Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4026  Illegal escape sequence at position 27 in string: '\\#'
4027
4028Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4029  Illegal escape sequence at position 6 in string: '\\ '
4030")})));
4031end BadEscape1;
4032
4033
4034model BadEscape2
4035    Real '\qabc\ def\nghi\\xjkl\?mno\#' = 1;
4036        Real x = '\qabc\ def\nghi\\xjkl\?mno\#';
4037
4038    annotation(__JModelica(UnitTesting(tests={
4039        ErrorTestCase(
4040            name="BadEscape2",
4041            description="Illegal escape sequences in quoted identifier",
4042            errorMessage="
40436 errors found:
4044
4045Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4046  Illegal escape sequence at position 2 in quoted identifier: '\\q'
4047
4048Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4049  Illegal escape sequence at position 28 in quoted identifier: '\\#'
4050
4051Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4052  Illegal escape sequence at position 7 in quoted identifier: '\\ '
4053
4054Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4055  Illegal escape sequence at position 2 in quoted identifier: '\\q'
4056
4057Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4058  Illegal escape sequence at position 28 in quoted identifier: '\\#'
4059
4060Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4061  Illegal escape sequence at position 7 in quoted identifier: '\\ '
4062")})));
4063end BadEscape2;
4064
4065
4066model LibWithVerTest1
4067    LibWithVer.Test a;
4068
4069    annotation(__JModelica(UnitTesting(tests={
4070        FlatteningTestCase(
4071            name="LibWithVerTest1",
4072            description="Load library with version # in name",
4073            modelicaLibraries="LibWithVer 1.2",
4074            flatModel="
4075fclass NameTests.LibWithVerTest1
4076 Real a.x = time;
4077end NameTests.LibWithVerTest1;
4078")})));
4079end LibWithVerTest1;
4080
4081
4082model ProtectedComponent1
4083    model A
4084        B b;
4085    protected
4086        Real y = time;
4087    end A;
4088   
4089    model B
4090    protected 
4091        C c;
4092    end B;
4093   
4094    model C
4095        Real x = time;
4096    end C;
4097   
4098    A a;
4099
4100    annotation(__JModelica(UnitTesting(tests={
4101        FlatteningTestCase(
4102            name="ProtectedComponent1",
4103            description="Check that variables in protected components are marked as protected in the flat model",
4104            flatModel="
4105fclass NameTests.ProtectedComponent1
4106protected
4107 Real a.b.c.x = time;
4108 Real a.y = time;
4109end NameTests.ProtectedComponent1;
4110")})));
4111end ProtectedComponent1;
4112
4113
4114model ClassThroughComponent1
4115    model A
4116        package B
4117            constant Real x = 1;
4118        end B;
4119       
4120        parameter Real y = 2;
4121    end A;
4122   
4123    A a;
4124    parameter Real z = a.B.x * a.y;
4125
4126    annotation(__JModelica(UnitTesting(tests={
4127        ErrorTestCase(
4128            name="ClassThroughComponent1",
4129            description="",
4130            errorMessage="
41311 errors found:
4132
4133Error at line 11, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4134  Can not access non-function class through component access: 'a.B.x'
4135")})));
4136end ClassThroughComponent1;
4137
4138
4139model ClassThroughComponent2
4140    model A
4141        package B
4142            constant Real x = 1;
4143        end B;
4144       
4145        parameter Real y = 2;
4146    end A;
4147   
4148    model C
4149        A a;
4150    end C;
4151   
4152    C c;
4153    parameter Real z = c.a.B.x * c.a.y;
4154
4155    annotation(__JModelica(UnitTesting(tests={
4156        ErrorTestCase(
4157            name="ClassThroughComponent2",
4158            description="",
4159            errorMessage="
41601 errors found:
4161
4162Error at line 15, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4163  Can not access non-function class through component access: 'c.a.B.x'
4164")})));
4165end ClassThroughComponent2;
4166
4167
4168model ClassThroughComponent3
4169    model A
4170        package B
4171            constant Real x = 1;
4172        end B;
4173       
4174        parameter Real y = 2;
4175    end A;
4176   
4177    model C
4178        A a[2];
4179    end C;
4180   
4181    C c;
4182    parameter Real z = c.a[1].B.x * c.a[1].y;
4183
4184    annotation(__JModelica(UnitTesting(tests={
4185        ErrorTestCase(
4186            name="ClassThroughComponent3",
4187            description="",
4188            errorMessage="
41891 errors found:
4190
4191Error at line 15, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4192  Can not access non-function class through component access: 'c.a[1].B.x'
4193")})));
4194end ClassThroughComponent3;
4195
4196
4197model ClassThroughComponent4
4198    model A
4199        package B
4200            model C
4201                parameter Real x = 1;
4202            end C;
4203        end B;
4204       
4205        parameter Real y = 2;
4206    end A;
4207   
4208    A a;
4209    a.C c;
4210
4211    annotation(__JModelica(UnitTesting(tests={
4212        ErrorTestCase(
4213            name="ClassThroughComponent4",
4214            description="",
4215            errorMessage="
42161 errors found:
4217
4218Error at line 13, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4219  Cannot find class declaration for a
4220")})));
4221end ClassThroughComponent4;
4222
4223
4224model OrderFile1
4225    extends TestLib.Order.Order1;
4226
4227annotation(__JModelica(UnitTesting(tests={
4228    InstClassMethodTestCase(
4229        name="OrderFile1",
4230        description="Correction of package.order: correct file",
4231        modelicaLibraries="TestLib",
4232        methodName="testOrderHelper",
4233        methodResult="[A, E, B, C, F, D]"
4234)})));
4235end OrderFile1;
4236
4237
4238model OrderFile2
4239    extends TestLib.Order.Order2;
4240
4241annotation(__JModelica(UnitTesting(tests={
4242    InstClassMethodTestCase(
4243        name="OrderFile2",
4244        description="Correction of package.order: package.mo contents in wrong order",
4245        modelicaLibraries="TestLib",
4246        methodName="testOrderHelper",
4247        methodResult="[F, E, A, B, C, D]"
4248)})));
4249end OrderFile2;
4250
4251
4252model OrderFile3
4253    extends TestLib.Order.Order3;
4254
4255annotation(__JModelica(UnitTesting(tests={
4256    InstClassMethodTestCase(
4257        name="OrderFile3",
4258        description="Correction of package.order: class file has wrong case",
4259        modelicaLibraries="TestLib",
4260        methodName="testOrderHelper",
4261        methodResult="[A, B, F, C, D, E]"
4262)})));
4263end OrderFile3;
4264
4265
4266model OrderFile4
4267    extends TestLib.Order.Order4;
4268
4269annotation(__JModelica(UnitTesting(tests={
4270    InstClassMethodTestCase(
4271        name="OrderFile4",
4272        description="Correction of package.order: wrong class names in package.order",
4273        modelicaLibraries="TestLib",
4274        methodName="testOrderHelper",
4275        methodResult="[A, B, C, D, E, F]"
4276)})));
4277end OrderFile4;
4278
4279end NameTests;
Note: See TracBrowser for help on using the repository browser.