source: trunk/Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo @ 13456

Last change on this file since 13456 was 13456, checked in by molsson, 3 months ago

#5827 Merged revision(s) from branches/dev-mo-2267:

File size: 93.9 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
3018    annotation(__JModelica(UnitTesting(tests={
3019        ErrorTestCase(
3020            name="ConditionalComponentTest1_Err",
3021            description="Test of type checking of conditional components.",
3022            errorMessage="
30231 errors found:
3024
3025Error at line 2, column 3, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NON_BOOLEAN_CONDITIONAL_GUARD:
3026  The guard expression of a conditional component should be a 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
3034    annotation(__JModelica(UnitTesting(tests={
3035        ErrorTestCase(
3036            name="ConditionalComponentTest2_Err",
3037            description="Test of type checking of conditional components.",
3038            errorMessage="
30391 errors found:
3040
3041Error at line 3, column 3, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NON_SCALAR_CONDITIONAL_GUARD:
3042  The guard expression of a conditional component should be a scalar expression
3043")})));
3044end ConditionalComponentTest2_Err;
3045
3046model ConditionalComponentTest3_Err
3047  parameter Integer b[2] = {1,1};
3048  parameter Real x = 1 if b;
3049
3050    annotation(__JModelica(UnitTesting(tests={
3051        ErrorTestCase(
3052            name="ConditionalComponentTest3_Err",
3053            description="Test of type checking of conditional components.",
3054            errorMessage="
30552 errors found:
3056
3057Error at line 3, column 3, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NON_BOOLEAN_CONDITIONAL_GUARD:
3058  The guard expression of a conditional component should be a boolean expression
3059
3060Error at line 3, column 3, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NON_SCALAR_CONDITIONAL_GUARD:
3061  The guard expression of a conditional component should be a scalar expression
3062")})));
3063end ConditionalComponentTest3_Err;
3064
3065
3066model ConditionalComponentTest4
3067  parameter Boolean b = true;
3068  parameter Real x = 1 if b;
3069
3070        annotation(__JModelica(UnitTesting(tests={
3071                FlatteningTestCase(
3072                        name="ConditionalComponentTest4",
3073                        description="Test flattening of conditional components.",
3074                        flatModel="
3075fclass NameTests.ConditionalComponentTest4
3076 structural parameter Boolean b = true /* true */;
3077 parameter Real x = 1 /* 1 */;
3078
3079end NameTests.ConditionalComponentTest4;
3080")})));
3081end ConditionalComponentTest4;
3082
3083
3084model ConditionalComponentTest5
3085  package P
3086    constant Boolean b = true;
3087  end P;
3088  parameter Real x = 1 if P.b;
3089
3090        annotation(__JModelica(UnitTesting(tests={
3091                FlatteningTestCase(
3092                        name="ConditionalComponentTest5",
3093                        description="Test flattening of conditional components.",
3094                        flatModel="
3095fclass NameTests.ConditionalComponentTest5
3096 parameter Real x = 1 /* 1 */;
3097
3098end NameTests.ConditionalComponentTest5;
3099")})));
3100end ConditionalComponentTest5;
3101
3102model ConditionalComponentTest6_Err
3103  parameter Boolean b = false;
3104  parameter Real x = 1 if b;
3105  Real y = x; 
3106
3107    annotation(__JModelica(UnitTesting(tests={
3108        ErrorTestCase(
3109            name="ConditionalComponentTest6_Err",
3110            description="Test of type checking of conditional components.",
3111            errorMessage="
31121 errors found:
3113
3114Error at line 4, column 12, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3115  The component x is conditional: Access of conditional components is only valid in connect statements
3116")})));
3117end ConditionalComponentTest6_Err;
3118
3119model ConditionalComponentTest7_Err
3120  model M
3121    Real x = 2;
3122  end M;
3123  parameter Boolean b = false;
3124  M m if b;
3125  Real y = m.x; 
3126
3127    annotation(__JModelica(UnitTesting(tests={
3128        ErrorTestCase(
3129            name="ConditionalComponentTest7_Err",
3130            description="Test of type checking of conditional components.",
3131            errorMessage="
31321 errors found:
3133
3134Error at line 7, column 12, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3135  The component m is conditional: Access of conditional components is only valid in connect statements
3136")})));
3137end ConditionalComponentTest7_Err;
3138
3139model ConditionalComponentTest8
3140  parameter Boolean b = false;
3141  parameter Real x = 1 if b;
3142
3143        annotation(__JModelica(UnitTesting(tests={
3144                FlatteningTestCase(
3145                        name="ConditionalComponentTest8",
3146                        description="Test flattening of conditional components.",
3147                        flatModel="
3148fclass NameTests.ConditionalComponentTest8
3149 parameter Boolean b = false /* false */;
3150
3151end NameTests.ConditionalComponentTest8;
3152")})));
3153end ConditionalComponentTest8;
3154
3155model ConditionalComponentTest9
3156  model N
3157   Real z;
3158   equation
3159   z^2 = 4;
3160  end N;
3161
3162  model M
3163    Real x;
3164    N n;
3165    extends N;
3166    equation
3167    x = 3;
3168  end M;
3169
3170  parameter Boolean b = false;
3171  M m if b;
3172
3173
3174        annotation(__JModelica(UnitTesting(tests={
3175                FlatteningTestCase(
3176                        name="ConditionalComponentTest9",
3177                        description="Test flattening of conditional components.",
3178                        flatModel="
3179fclass NameTests.ConditionalComponentTest9
3180 parameter Boolean b = false /* false */;
3181
3182end NameTests.ConditionalComponentTest9;
3183")})));
3184end ConditionalComponentTest9;
3185
3186model ConditionalComponentTest10
3187  connector RealInput = input Real;
3188  connector RealOutput = output Real;
3189
3190  model Source
3191    RealOutput y = p;
3192    parameter Real p = 1;
3193  end Source;
3194
3195  model Sink
3196    RealInput u;
3197  end Sink;
3198
3199  model M
3200    parameter Boolean b = true;
3201    RealInput u1 if b;
3202    RealInput u2 if not b;
3203    RealOutput y;
3204  equation
3205    connect(u1,y);
3206    connect(u2,y);
3207  end M;
3208
3209  parameter Boolean b = true;
3210  M m(b=b);
3211  Source source1 if b;
3212  Source source2 if not b;
3213  Sink sink;
3214  equation
3215  connect(source1.y,m.u1);
3216  connect(source2.y,m.u2);
3217  connect(m.y,sink.u);
3218
3219
3220        annotation(__JModelica(UnitTesting(tests={
3221                FlatteningTestCase(
3222                        name="ConditionalComponentTest10",
3223                        description="Test flattening of conditional components",
3224                        flatModel="
3225fclass NameTests.ConditionalComponentTest10
3226 structural parameter Boolean b = true /* true */;
3227 structural parameter Boolean m.b = true /* true */;
3228 NameTests.ConditionalComponentTest10.RealInput m.u1;
3229 NameTests.ConditionalComponentTest10.RealOutput m.y;
3230 NameTests.ConditionalComponentTest10.RealOutput source1.y = source1.p;
3231 parameter Real source1.p = 1 /* 1 */;
3232 NameTests.ConditionalComponentTest10.RealInput sink.u;
3233equation
3234 m.u1 = source1.y;
3235 m.y = sink.u;
3236 m.u1 = m.y;
3237
3238public
3239 type NameTests.ConditionalComponentTest10.RealInput = Real;
3240 type NameTests.ConditionalComponentTest10.RealOutput = Real;
3241end NameTests.ConditionalComponentTest10;
3242")})));
3243end ConditionalComponentTest10;
3244
3245model ConditionalComponentTest11
3246  connector RealInput = input Real;
3247  connector RealOutput = output Real;
3248
3249  model Source
3250    RealOutput y = p;
3251    parameter Real p = 1;
3252  end Source;
3253
3254  model Sink
3255    RealInput u;
3256  end Sink;
3257
3258  model M
3259    parameter Boolean b = true;
3260    RealInput u1 if b;
3261    RealInput u2 if not b;
3262    RealOutput y;
3263  equation
3264    connect(u1,y);
3265    connect(u2,y);
3266  end M;
3267
3268  parameter Boolean b = false;
3269  M m(b=b);
3270  Source source1 if b;
3271  Source source2 if not b;
3272  Sink sink;
3273  equation
3274  connect(source1.y,m.u1);
3275  connect(source2.y,m.u2);
3276  connect(m.y,sink.u);
3277
3278
3279        annotation(__JModelica(UnitTesting(tests={
3280                FlatteningTestCase(
3281                        name="ConditionalComponentTest11",
3282                        description="Test flattening of conditional components",
3283                        flatModel="
3284fclass NameTests.ConditionalComponentTest11
3285 structural parameter Boolean b = false /* false */;
3286 structural parameter Boolean m.b = false /* false */;
3287 NameTests.ConditionalComponentTest11.RealInput m.u2;
3288 NameTests.ConditionalComponentTest11.RealOutput m.y;
3289 NameTests.ConditionalComponentTest11.RealOutput source2.y = source2.p;
3290 parameter Real source2.p = 1 /* 1 */;
3291 NameTests.ConditionalComponentTest11.RealInput sink.u;
3292equation
3293 m.u2 = source2.y;
3294 m.y = sink.u;
3295 m.u2 = m.y;
3296
3297public
3298 type NameTests.ConditionalComponentTest11.RealInput = Real;
3299 type NameTests.ConditionalComponentTest11.RealOutput = Real;
3300end NameTests.ConditionalComponentTest11;
3301")})));
3302end ConditionalComponentTest11;
3303
3304
3305model ConditionalComponentTest12
3306        model A
3307                parameter Boolean flag = true;
3308                B b1 if flag;
3309                B b2 if not flag;
3310                Real z1 if flag;
3311                Real z2 if not flag;
3312        end A;
3313       
3314        model B
3315                Real x;
3316        end B;
3317       
3318        Real y = 1;
3319        A a(b1(x = y), b2(x = y), z1 = y, z2 = y);
3320
3321        annotation(__JModelica(UnitTesting(tests={
3322                FlatteningTestCase(
3323                        name="ConditionalComponentTest12",
3324                        description="Modifying conditional component",
3325                        flatModel="
3326fclass NameTests.ConditionalComponentTest12
3327 Real y = 1;
3328 structural parameter Boolean a.flag = true /* true */;
3329 Real a.b1.x = y;
3330 Real a.z1 = y;
3331end NameTests.ConditionalComponentTest12;
3332")})));
3333end ConditionalComponentTest12;
3334
3335
3336model ConditionalComponentTest13_Err
3337        model A
3338                Real x;
3339        end A;
3340       
3341        model B
3342        parameter Boolean flag = true;
3343        A a1 if flag;
3344        A a2 if not flag;
3345        end B;
3346       
3347    Real y1 if b.flag;
3348    Real y2 if not b.flag;
3349        B b(a1(x = y1), a2(x = y2));
3350
3351    annotation(__JModelica(UnitTesting(tests={
3352        ErrorTestCase(
3353            name="ConditionalComponentTest13_Err",
3354            description="Using value of conditional component in modification for other conditional component",
3355            errorMessage="
33562 errors found:
3357
3358Error at line 14, column 13, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3359  The component y1 is conditional: Access of conditional components is only valid in connect statements
3360
3361Error at line 14, column 25, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3362  The component y2 is conditional: Access of conditional components is only valid in connect statements
3363")})));
3364end ConditionalComponentTest13_Err;
3365
3366model ConditionalComponentTest14
3367    record R
3368        parameter Real x;
3369    end R;
3370   
3371    parameter R r if false;
3372
3373    annotation(__JModelica(UnitTesting(tests={
3374        FlatteningTestCase(
3375            name="ConditionalComponentTest14",
3376            description="Flattening type of conditional component",
3377            flatModel="
3378fclass NameTests.ConditionalComponentTest14
3379end NameTests.ConditionalComponentTest14;
3380")})));
3381end ConditionalComponentTest14;
3382
3383model AttributeDot1
3384  Real x=1;
3385  parameter Real p = x.start;
3386
3387    annotation(__JModelica(UnitTesting(tests={
3388        ErrorTestCase(
3389            name="AttributeDot1",
3390            description="Access to attribute with dot notation",
3391            errorMessage="
33921 errors found:
3393
3394Error at line 3, column 22, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3395  Can not access attribute of primitive with dot notation: x.start
3396")})));
3397end AttributeDot1;
3398
3399
3400
3401model ComplexExpInDer1
3402 Real x;
3403 Real y;
3404equation
3405 der(x * y) = 0;
3406
3407        annotation(__JModelica(UnitTesting(tests={
3408                FlatteningTestCase(
3409                        name="ComplexExpInDer1",
3410                        description="",
3411                        flatModel="
3412fclass NameTests.ComplexExpInDer1
3413 Real x;
3414 Real y;
3415equation
3416 x * der(y) + der(x) * y = 0;
3417end NameTests.ComplexExpInDer1;
3418")})));
3419end ComplexExpInDer1;
3420
3421
3422model ComplexExpInDer2
3423 Real x;
3424 Real y;
3425equation
3426 der(der(x + 1) - y) = 0;
3427
3428        annotation(__JModelica(UnitTesting(tests={
3429                FlatteningTestCase(
3430                        name="ComplexExpInDer2",
3431                        description="",
3432                        flatModel="
3433fclass NameTests.ComplexExpInDer2
3434 Real x;
3435 Real y;
3436equation
3437 der(x,2) - der(y) = 0;
3438end NameTests.ComplexExpInDer2;
3439")})));
3440end ComplexExpInDer2;
3441
3442
3443model ComplexExpInDer3
3444 Real x;
3445 Real y;
3446equation
3447 der({x, y}) = zeros(2);
3448
3449        annotation(__JModelica(UnitTesting(tests={
3450                FlatteningTestCase(
3451                        name="ComplexExpInDer3",
3452                        description="",
3453                        flatModel="
3454fclass NameTests.ComplexExpInDer3
3455 Real x;
3456 Real y;
3457equation
3458 {der(x),der(y)} = zeros(2);
3459end NameTests.ComplexExpInDer3;
3460")})));
3461end ComplexExpInDer3;
3462
3463model EmptyAnnotationTest
3464 
3465  model M
3466  annotation();
3467  end M;
3468  M m;
3469        annotation(__JModelica(UnitTesting(tests={
3470                FlatteningTestCase(
3471                        name="EmptyAnnotationTest",
3472                        description="Test that it is ok to have an empty annotation.",
3473                        flatModel="
3474fclass NameTests.EmptyAnnotationTest
3475end NameTests.EmptyAnnotationTest;
3476")})));
3477end EmptyAnnotationTest;
3478
3479model EmptyModificationTest
3480 
3481  model M
3482  Real x()=1;
3483  end M;
3484  M m;
3485        annotation(__JModelica(UnitTesting(tests={
3486                FlatteningTestCase(
3487                        name="EmptyModificationTest",
3488                        description="Test that it is ok to have an empty modification.",
3489                        flatModel="
3490fclass NameTests.EmptyModificationTest
3491 Real m.x = 1;
3492end NameTests.EmptyModificationTest;
3493")})));
3494end EmptyModificationTest;
3495
3496model FunctionCallLeftTest
3497  function f
3498   input Real x1;
3499   output Real y1;
3500  algorithm
3501   y1:=2*x1;
3502  end f;
3503 
3504   Real x;
3505  algorithm
3506   (x) := f(1);
3507       
3508        annotation(__JModelica(UnitTesting(tests={
3509                FlatteningTestCase(
3510                        name="FunctionCallLeftTest",
3511                        description="Test so that it is ok to have only one output argument in a function call left statement.",
3512                        flatModel="
3513fclass NameTests.FunctionCallLeftTest
3514 Real x;
3515algorithm
3516 (x) := NameTests.FunctionCallLeftTest.f(1);
3517
3518public
3519 function NameTests.FunctionCallLeftTest.f
3520  input Real x1;
3521  output Real y1;
3522 algorithm
3523  y1 := 2 * x1;
3524  return;
3525 end NameTests.FunctionCallLeftTest.f;
3526
3527end NameTests.FunctionCallLeftTest;
3528")})));
3529end FunctionCallLeftTest;
3530
3531
3532model PreAliasTest1
3533        discrete Real x;
3534        discrete Real y;
3535initial equation
3536        pre(x) = 42;
3537equation
3538        x = y;
3539        x = pre(x) * pre(y) + 3.14;
3540
3541        annotation(__JModelica(UnitTesting(tests={
3542                TransformCanonicalTestCase(
3543                        name="PreAliasTest1",
3544                        description="Test so that pre() variables are rewritten correctly",
3545                        flatModel="
3546fclass NameTests.PreAliasTest1
3547 discrete Real x;
3548initial equation 
3549 pre(x) = 42;
3550equation
3551 x = pre(x) * pre(x) + 3.14;
3552end NameTests.PreAliasTest1;
3553")})));
3554end PreAliasTest1;
3555
3556
3557model AssignedInWhenRecursion
3558    model A
3559        parameter Boolean x = true;
3560    end A;
3561   
3562    model B
3563        Real y = 2;
3564    end B;
3565   
3566    parameter Integer n = if a.x then 2 else 3;
3567    A a;
3568    B b[n];
3569end AssignedInWhenRecursion;
3570
3571model WhenInExtendsTest
3572        model A
3573                Real x;
3574                Real y;
3575                Integer i;
3576                parameter Boolean b = false;
3577        equation
3578                i = 1;
3579                when initial() then
3580                        if b then
3581                                y = 2 + i;
3582                        else
3583                                y = 4;
3584                        end if;
3585                end when;
3586                when time>=3 then
3587                        x = 3;
3588                end when;
3589        end A;
3590       
3591        model B
3592                extends A;
3593        end B;
3594       
3595        B b;
3596
3597        annotation(__JModelica(UnitTesting(tests={
3598                FlatteningTestCase(
3599                        name="WhenInExtendsTest",
3600                        description="",
3601                        flatModel="
3602fclass NameTests.WhenInExtendsTest
3603 discrete Real b.x;
3604 discrete Real b.y;
3605 discrete Integer b.i;
3606 structural parameter Boolean b.b = false /* false */;
3607equation
3608 b.i = 1;
3609 when initial() then
3610  if false then
3611   b.y = 2 + b.i;
3612  else
3613   b.y = 4;
3614  end if;
3615 end when;
3616 when time >= 3 then
3617  b.x = 3;
3618 end when;
3619end NameTests.WhenInExtendsTest;
3620")})));
3621end WhenInExtendsTest;
3622
3623
3624model InheritInputTest1
3625        connector A
3626                Real x;
3627        end A;
3628       
3629        input A a;
3630
3631        annotation(__JModelica(UnitTesting(tests={
3632                FlatteningTestCase(
3633                        name="InheritInputTest1",
3634                        description="Check that input is propagated to child components",
3635                        flatModel="
3636fclass NameTests.InheritInputTest1
3637 input Real a.x;
3638end NameTests.InheritInputTest1;
3639")})));
3640end InheritInputTest1;
3641
3642
3643model InheritInputTest2
3644    connector A
3645        Real x;
3646    end A;
3647       
3648        connector B
3649                A a;
3650        end B;
3651   
3652    input B b;
3653
3654        annotation(__JModelica(UnitTesting(tests={
3655                FlatteningTestCase(
3656                        name="InheritInputTest2",
3657                        description="Check that input is propagated to child components: nested",
3658                        flatModel="
3659fclass NameTests.InheritInputTest2
3660 input Real b.a.x;
3661end NameTests.InheritInputTest2;
3662")})));
3663end InheritInputTest2;
3664
3665
3666model InheritInputTest3
3667    connector A
3668        input Real x;
3669    end A;
3670   
3671    input A a;
3672
3673    annotation(__JModelica(UnitTesting(tests={
3674        ErrorTestCase(
3675            name="InheritInputTest3",
3676            description="Check that it isn't allowed to declare a component containing an input as input",
3677            errorMessage="
36781 errors found:
3679
3680Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3681  Can't declare x as input, since it contains a component declared as input or output
3682")})));
3683end InheritInputTest3;
3684
3685
3686model InheritInputTest4
3687    connector A
3688        output Real x;
3689    end A;
3690   
3691    input A a;
3692
3693    annotation(__JModelica(UnitTesting(tests={
3694        ErrorTestCase(
3695            name="InheritInputTest4",
3696            description="Check that it isn't allowed to declare a component containing an output as input",
3697            errorMessage="
36981 errors found:
3699
3700Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3701  Can't declare x as output, since it contains a component declared as input or output
3702")})));
3703end InheritInputTest4;
3704
3705
3706model InheritOutputTest1
3707    connector A
3708        Real x;
3709    end A;
3710   
3711    output A a;
3712
3713        annotation(__JModelica(UnitTesting(tests={
3714                FlatteningTestCase(
3715                        name="InheritOutputTest1",
3716                        description="Check that output is propagated to child components",
3717                        flatModel="
3718fclass NameTests.InheritOutputTest1
3719 output Real a.x;
3720end NameTests.InheritOutputTest1;
3721")})));
3722end InheritOutputTest1;
3723
3724
3725model InheritOutputTest2
3726    connector A
3727        Real x;
3728    end A;
3729   
3730    connector B
3731        A a;
3732    end B;
3733   
3734    output B b;
3735
3736        annotation(__JModelica(UnitTesting(tests={
3737                FlatteningTestCase(
3738                        name="InheritOutputTest2",
3739                        description="Check that output is propagated to child components: nested",
3740                        flatModel="
3741fclass NameTests.InheritOutputTest2
3742 output Real b.a.x;
3743end NameTests.InheritOutputTest2;
3744")})));
3745end InheritOutputTest2;
3746
3747
3748model InheritOutputTest3
3749    connector A
3750        output Real x;
3751    end A;
3752   
3753    output A a;
3754
3755    annotation(__JModelica(UnitTesting(tests={
3756        ErrorTestCase(
3757            name="InheritOutputTest3",
3758            description="Check that it isn't allowed to declare a component containing an output as output",
3759            errorMessage="
37601 errors found:
3761
3762Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3763  Can't declare x as output, since it contains a component declared as input or output
3764")})));
3765end InheritOutputTest3;
3766
3767
3768model InheritOutputTest4
3769    connector A
3770        input Real x;
3771    end A;
3772   
3773    output A a;
3774
3775    annotation(__JModelica(UnitTesting(tests={
3776        ErrorTestCase(
3777            name="InheritOutputTest4",
3778            description="Check that it isn't allowed to declare a component containing an input as output",
3779            errorMessage="
37801 errors found:
3781
3782Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3783  Can't declare x as input, since it contains a component declared as input or output
3784")})));
3785end InheritOutputTest4;
3786
3787
3788model InheritFlowTest1
3789    connector A
3790        Real x;
3791    end A;
3792
3793    connector B
3794                A ap;
3795        flow A af;
3796        end B;
3797       
3798        B b1, b2;
3799equation
3800        connect(b1, b2);
3801
3802annotation(__JModelica(UnitTesting(tests={
3803    FlatteningTestCase(
3804        name="InheritFlowTest1",
3805        description="Check that flow is propagated to child components",
3806        flatModel="
3807fclass NameTests.InheritFlowTest1
3808 potential Real b1.ap.x;
3809 flow Real b1.af.x;
3810 potential Real b2.ap.x;
3811 flow Real b2.af.x;
3812equation
3813 - b1.af.x - b2.af.x = 0.0;
3814 b1.ap.x = b2.ap.x;
3815 b1.af.x = 0.0;
3816 b2.af.x = 0.0;
3817end NameTests.InheritFlowTest1;
3818")})));
3819end InheritFlowTest1;
3820
3821
3822model InheritFlowTest2
3823    connector A
3824        flow Real x;
3825    end A;
3826   
3827    flow A a;
3828
3829    annotation(__JModelica(UnitTesting(tests={
3830        ErrorTestCase(
3831            name="InheritFlowTest2",
3832            description="Check that it isn't allowed to declare a component containing an flow as flow",
3833            errorMessage="
38341 errors found:
3835
3836Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3837  Can't declare x as flow, since it contains a component declared as flow
3838")})));
3839end InheritFlowTest2;
3840
3841
3842
3843model DuplicateVariables1
3844    model A
3845      Real x(start=1, min=2) = 3;
3846    end A;
3847    extends A;
3848   
3849    Real x(start=1, min=2) = 3;
3850
3851    annotation(__JModelica(UnitTesting(tests={
3852        FlatteningTestCase(
3853            name="DuplicateVariables1",
3854            description="Test that identical components in base classes are handled correctly",
3855            flatModel="
3856fclass NameTests.DuplicateVariables1
3857 Real x(start = 1,min = 2) = 3;
3858end NameTests.DuplicateVariables1;
3859")})));
3860end DuplicateVariables1;
3861
3862
3863model DuplicateVariables2
3864    model A
3865        Real x;
3866    equation
3867        der(x) = time;
3868    end A;
3869   
3870    model B
3871        A a;
3872    end B;
3873   
3874    extends B;
3875    A a;
3876
3877    annotation(__JModelica(UnitTesting(tests={
3878        FlatteningTestCase(
3879            name="DuplicateVariables2",
3880            description="Test that identical components in base classes are handled correctly",
3881            flatModel="
3882fclass NameTests.DuplicateVariables2
3883 Real a.x;
3884equation
3885 der(a.x) = time;
3886end NameTests.DuplicateVariables2;
3887")})));
3888end DuplicateVariables2;
3889
3890
3891model DuplicateVariables3
3892    Real x;
3893    Real x;
3894
3895    annotation(__JModelica(UnitTesting(tests={
3896        ErrorTestCase(
3897            name="DuplicateVariables3",
3898            description="",
3899            errorMessage="
39001 errors found:
3901
3902Error at line 3, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3903  Duplicate component in same class: Real x
3904")})));
3905end DuplicateVariables3;
3906
3907
3908model DuplicateVariables5
3909    model A
3910      Real x(start=1, min=2) = 3;
3911    end A;
3912   
3913    model B
3914        extends A;
3915        Real x(start=1, min=2) = 3;
3916    end B;
3917   
3918    B b[2];
3919
3920    annotation(__JModelica(UnitTesting(tests={
3921        FlatteningTestCase(
3922            name="DuplicateVariables5",
3923            description="Test that identical components in base classes are handled correctly",
3924            flatModel="
3925fclass NameTests.DuplicateVariables5
3926 Real b[1].x(start = 1,min = 2) = 3;
3927 Real b[2].x(start = 1,min = 2) = 3;
3928end NameTests.DuplicateVariables5;
3929")})));
3930end DuplicateVariables5;
3931
3932
3933model DuplicateVariables6
3934    model A
3935        Real x;
3936        Real x;
3937    end A;
3938   
3939    A a[2];
3940
3941    annotation(__JModelica(UnitTesting(tests={
3942        ErrorTestCase(
3943            name="DuplicateVariables6",
3944            description="",
3945            errorMessage="
39461 errors found:
3947
3948Error at line 4, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
3949In component a:
3950  Duplicate component in same class: Real x
3951")})));
3952end DuplicateVariables6;
3953
3954
3955
3956model BadEscape1
3957        parameter String a = "\qabc\ def\nghi\\xjkl\?mno\#";
3958
3959    annotation(__JModelica(UnitTesting(tests={
3960        ErrorTestCase(
3961            name="BadEscape1",
3962            description="Illegal escape sequences in string",
3963            errorMessage="
39643 errors found:
3965
3966Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3967  Illegal escape sequence at position 1 in string: '\\q'
3968
3969Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3970  Illegal escape sequence at position 27 in string: '\\#'
3971
3972Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3973  Illegal escape sequence at position 6 in string: '\\ '
3974")})));
3975end BadEscape1;
3976
3977
3978model BadEscape2
3979    Real '\qabc\ def\nghi\\xjkl\?mno\#' = 1;
3980        Real x = '\qabc\ def\nghi\\xjkl\?mno\#';
3981
3982    annotation(__JModelica(UnitTesting(tests={
3983        ErrorTestCase(
3984            name="BadEscape2",
3985            description="Illegal escape sequences in quoted identifier",
3986            errorMessage="
39876 errors found:
3988
3989Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3990  Illegal escape sequence at position 2 in quoted identifier: '\\q'
3991
3992Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3993  Illegal escape sequence at position 28 in quoted identifier: '\\#'
3994
3995Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3996  Illegal escape sequence at position 7 in quoted identifier: '\\ '
3997
3998Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3999  Illegal escape sequence at position 2 in quoted identifier: '\\q'
4000
4001Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4002  Illegal escape sequence at position 28 in quoted identifier: '\\#'
4003
4004Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4005  Illegal escape sequence at position 7 in quoted identifier: '\\ '
4006")})));
4007end BadEscape2;
4008
4009
4010model LibWithVerTest1
4011    LibWithVer.Test a;
4012
4013    annotation(__JModelica(UnitTesting(tests={
4014        FlatteningTestCase(
4015            name="LibWithVerTest1",
4016            description="Load library with version # in name",
4017            modelicaLibraries="LibWithVer 1.2",
4018            flatModel="
4019fclass NameTests.LibWithVerTest1
4020 Real a.x = time;
4021end NameTests.LibWithVerTest1;
4022")})));
4023end LibWithVerTest1;
4024
4025
4026model ProtectedComponent1
4027    model A
4028        B b;
4029    protected
4030        Real y = time;
4031    end A;
4032   
4033    model B
4034    protected 
4035        C c;
4036    end B;
4037   
4038    model C
4039        Real x = time;
4040    end C;
4041   
4042    A a;
4043
4044    annotation(__JModelica(UnitTesting(tests={
4045        FlatteningTestCase(
4046            name="ProtectedComponent1",
4047            description="Check that variables in protected components are marked as protected in the flat model",
4048            flatModel="
4049fclass NameTests.ProtectedComponent1
4050protected
4051 Real a.b.c.x = time;
4052 Real a.y = time;
4053end NameTests.ProtectedComponent1;
4054")})));
4055end ProtectedComponent1;
4056
4057
4058model ClassThroughComponent1
4059    model A
4060        package B
4061            constant Real x = 1;
4062        end B;
4063       
4064        parameter Real y = 2;
4065    end A;
4066   
4067    A a;
4068    parameter Real z = a.B.x * a.y;
4069
4070    annotation(__JModelica(UnitTesting(tests={
4071        ErrorTestCase(
4072            name="ClassThroughComponent1",
4073            description="",
4074            errorMessage="
40751 errors found:
4076
4077Error at line 11, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4078  Can not access non-function class through component access: 'a.B.x'
4079")})));
4080end ClassThroughComponent1;
4081
4082
4083model ClassThroughComponent2
4084    model A
4085        package B
4086            constant Real x = 1;
4087        end B;
4088       
4089        parameter Real y = 2;
4090    end A;
4091   
4092    model C
4093        A a;
4094    end C;
4095   
4096    C c;
4097    parameter Real z = c.a.B.x * c.a.y;
4098
4099    annotation(__JModelica(UnitTesting(tests={
4100        ErrorTestCase(
4101            name="ClassThroughComponent2",
4102            description="",
4103            errorMessage="
41041 errors found:
4105
4106Error at line 15, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4107  Can not access non-function class through component access: 'c.a.B.x'
4108")})));
4109end ClassThroughComponent2;
4110
4111
4112model ClassThroughComponent3
4113    model A
4114        package B
4115            constant Real x = 1;
4116        end B;
4117       
4118        parameter Real y = 2;
4119    end A;
4120   
4121    model C
4122        A a[2];
4123    end C;
4124   
4125    C c;
4126    parameter Real z = c.a[1].B.x * c.a[1].y;
4127
4128    annotation(__JModelica(UnitTesting(tests={
4129        ErrorTestCase(
4130            name="ClassThroughComponent3",
4131            description="",
4132            errorMessage="
41331 errors found:
4134
4135Error at line 15, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4136  Can not access non-function class through component access: 'c.a[1].B.x'
4137")})));
4138end ClassThroughComponent3;
4139
4140
4141model ClassThroughComponent4
4142    model A
4143        package B
4144            model C
4145                parameter Real x = 1;
4146            end C;
4147        end B;
4148       
4149        parameter Real y = 2;
4150    end A;
4151   
4152    A a;
4153    a.C c;
4154
4155    annotation(__JModelica(UnitTesting(tests={
4156        ErrorTestCase(
4157            name="ClassThroughComponent4",
4158            description="",
4159            errorMessage="
41601 errors found:
4161
4162Error at line 13, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4163  Cannot find class declaration for a
4164")})));
4165end ClassThroughComponent4;
4166
4167
4168model OrderFile1
4169    extends TestLib.Order.Order1;
4170
4171annotation(__JModelica(UnitTesting(tests={
4172    InstClassMethodTestCase(
4173        name="OrderFile1",
4174        description="Correction of package.order: correct file",
4175        modelicaLibraries="TestLib",
4176        methodName="testOrderHelper",
4177        methodResult="[A, E, B, C, F, D]"
4178)})));
4179end OrderFile1;
4180
4181
4182model OrderFile2
4183    extends TestLib.Order.Order2;
4184
4185annotation(__JModelica(UnitTesting(tests={
4186    InstClassMethodTestCase(
4187        name="OrderFile2",
4188        description="Correction of package.order: package.mo contents in wrong order",
4189        modelicaLibraries="TestLib",
4190        methodName="testOrderHelper",
4191        methodResult="[F, E, A, B, C, D]"
4192)})));
4193end OrderFile2;
4194
4195
4196model OrderFile3
4197    extends TestLib.Order.Order3;
4198
4199annotation(__JModelica(UnitTesting(tests={
4200    InstClassMethodTestCase(
4201        name="OrderFile3",
4202        description="Correction of package.order: class file has wrong case",
4203        modelicaLibraries="TestLib",
4204        methodName="testOrderHelper",
4205        methodResult="[A, B, F, C, D, E]"
4206)})));
4207end OrderFile3;
4208
4209
4210model OrderFile4
4211    extends TestLib.Order.Order4;
4212
4213annotation(__JModelica(UnitTesting(tests={
4214    InstClassMethodTestCase(
4215        name="OrderFile4",
4216        description="Correction of package.order: wrong class names in package.order",
4217        modelicaLibraries="TestLib",
4218        methodName="testOrderHelper",
4219        methodResult="[A, B, C, D, E, F]"
4220)})));
4221end OrderFile4;
4222
4223end NameTests;
Note: See TracBrowser for help on using the repository browser.