source: branches/dev-mo-2617/Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo @ 13898

Last change on this file since 13898 was 13898, checked in by molsson, 6 weeks ago

#5843 Moved type checking of conditional attributes so that it is always done.

File size: 95.7 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 structural 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 structural 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
3383
3384model ConditionalComponentTest15_Err
3385    connector C
3386        Real x;
3387    end C;
3388   
3389    parameter Integer b[2] = {1,1};
3390    C c if b;
3391annotation(__JModelica(UnitTesting(tests={
3392    ErrorTestCase(
3393        description="Test of type checking of conditional composite component.",
3394        errorMessage="
33952 errors found:
3396
3397Error at line 7, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NON_BOOLEAN_CONDITIONAL_GUARD:
3398  The guard expression of a conditional component should be a boolean expression
3399
3400Error at line 7, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', NON_SCALAR_CONDITIONAL_GUARD:
3401  The guard expression of a conditional component should be a scalar expression
3402")})));
3403end ConditionalComponentTest15_Err;
3404
3405
3406model ConditionalComponentTest16
3407    connector C
3408        Real x;
3409    end C;
3410   
3411    parameter Boolean b = false;
3412    C c if b;
3413annotation(__JModelica(UnitTesting(tests={
3414    FlatteningTestCase(
3415        description="Flattening conditional composite component",
3416        flatModel="
3417fclass NameTests.ConditionalComponentTest16
3418 structural parameter Boolean b = false /* false */;
3419end NameTests.ConditionalComponentTest16;
3420")})));
3421end ConditionalComponentTest16;
3422
3423
3424model ConditionalComponentTest17
3425    connector C
3426        Real x;
3427    end C;
3428   
3429    parameter Boolean b = true;
3430    C c if b;
3431annotation(__JModelica(UnitTesting(tests={
3432    FlatteningTestCase(
3433        description="Flattening conditional composite component",
3434        flatModel="
3435fclass NameTests.ConditionalComponentTest17
3436 structural parameter Boolean b = true /* true */;
3437 potential Real c.x;
3438end NameTests.ConditionalComponentTest17;
3439")})));
3440end ConditionalComponentTest17;
3441
3442
3443
3444model AttributeDot1
3445  Real x=1;
3446  parameter Real p = x.start;
3447
3448    annotation(__JModelica(UnitTesting(tests={
3449        ErrorTestCase(
3450            name="AttributeDot1",
3451            description="Access to attribute with dot notation",
3452            errorMessage="
34531 errors found:
3454
3455Error at line 3, column 22, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3456  Can not access attribute of primitive with dot notation: x.start
3457")})));
3458end AttributeDot1;
3459
3460
3461
3462model ComplexExpInDer1
3463 Real x;
3464 Real y;
3465equation
3466 der(x * y) = 0;
3467
3468        annotation(__JModelica(UnitTesting(tests={
3469                FlatteningTestCase(
3470                        name="ComplexExpInDer1",
3471                        description="",
3472                        flatModel="
3473fclass NameTests.ComplexExpInDer1
3474 Real x;
3475 Real y;
3476equation
3477 x * der(y) + der(x) * y = 0;
3478end NameTests.ComplexExpInDer1;
3479")})));
3480end ComplexExpInDer1;
3481
3482
3483model ComplexExpInDer2
3484 Real x;
3485 Real y;
3486equation
3487 der(der(x + 1) - y) = 0;
3488
3489        annotation(__JModelica(UnitTesting(tests={
3490                FlatteningTestCase(
3491                        name="ComplexExpInDer2",
3492                        description="",
3493                        flatModel="
3494fclass NameTests.ComplexExpInDer2
3495 Real x;
3496 Real y;
3497equation
3498 der(x,2) - der(y) = 0;
3499end NameTests.ComplexExpInDer2;
3500")})));
3501end ComplexExpInDer2;
3502
3503
3504model ComplexExpInDer3
3505 Real x;
3506 Real y;
3507equation
3508 der({x, y}) = zeros(2);
3509
3510        annotation(__JModelica(UnitTesting(tests={
3511                FlatteningTestCase(
3512                        name="ComplexExpInDer3",
3513                        description="",
3514                        flatModel="
3515fclass NameTests.ComplexExpInDer3
3516 Real x;
3517 Real y;
3518equation
3519 {der(x),der(y)} = zeros(2);
3520end NameTests.ComplexExpInDer3;
3521")})));
3522end ComplexExpInDer3;
3523
3524model EmptyAnnotationTest
3525 
3526  model M
3527  annotation();
3528  end M;
3529  M m;
3530        annotation(__JModelica(UnitTesting(tests={
3531                FlatteningTestCase(
3532                        name="EmptyAnnotationTest",
3533                        description="Test that it is ok to have an empty annotation.",
3534                        flatModel="
3535fclass NameTests.EmptyAnnotationTest
3536end NameTests.EmptyAnnotationTest;
3537")})));
3538end EmptyAnnotationTest;
3539
3540model EmptyModificationTest
3541 
3542  model M
3543  Real x()=1;
3544  end M;
3545  M m;
3546        annotation(__JModelica(UnitTesting(tests={
3547                FlatteningTestCase(
3548                        name="EmptyModificationTest",
3549                        description="Test that it is ok to have an empty modification.",
3550                        flatModel="
3551fclass NameTests.EmptyModificationTest
3552 Real m.x = 1;
3553end NameTests.EmptyModificationTest;
3554")})));
3555end EmptyModificationTest;
3556
3557model FunctionCallLeftTest
3558  function f
3559   input Real x1;
3560   output Real y1;
3561  algorithm
3562   y1:=2*x1;
3563  end f;
3564 
3565   Real x;
3566  algorithm
3567   (x) := f(1);
3568       
3569        annotation(__JModelica(UnitTesting(tests={
3570                FlatteningTestCase(
3571                        name="FunctionCallLeftTest",
3572                        description="Test so that it is ok to have only one output argument in a function call left statement.",
3573                        flatModel="
3574fclass NameTests.FunctionCallLeftTest
3575 Real x;
3576algorithm
3577 (x) := NameTests.FunctionCallLeftTest.f(1);
3578
3579public
3580 function NameTests.FunctionCallLeftTest.f
3581  input Real x1;
3582  output Real y1;
3583 algorithm
3584  y1 := 2 * x1;
3585  return;
3586 end NameTests.FunctionCallLeftTest.f;
3587
3588end NameTests.FunctionCallLeftTest;
3589")})));
3590end FunctionCallLeftTest;
3591
3592
3593model PreAliasTest1
3594        discrete Real x;
3595        discrete Real y;
3596initial equation
3597        pre(x) = 42;
3598equation
3599        x = y;
3600        x = pre(x) * pre(y) + 3.14;
3601
3602        annotation(__JModelica(UnitTesting(tests={
3603                TransformCanonicalTestCase(
3604                        name="PreAliasTest1",
3605                        description="Test so that pre() variables are rewritten correctly",
3606                        flatModel="
3607fclass NameTests.PreAliasTest1
3608 discrete Real x;
3609initial equation 
3610 pre(x) = 42;
3611equation
3612 x = pre(x) * pre(x) + 3.14;
3613end NameTests.PreAliasTest1;
3614")})));
3615end PreAliasTest1;
3616
3617
3618model AssignedInWhenRecursion
3619    model A
3620        parameter Boolean x = true;
3621    end A;
3622   
3623    model B
3624        Real y = 2;
3625    end B;
3626   
3627    parameter Integer n = if a.x then 2 else 3;
3628    A a;
3629    B b[n];
3630end AssignedInWhenRecursion;
3631
3632model WhenInExtendsTest
3633        model A
3634                Real x;
3635                Real y;
3636                Integer i;
3637                parameter Boolean b = false;
3638        equation
3639                i = 1;
3640                when initial() then
3641                        if b then
3642                                y = 2 + i;
3643                        else
3644                                y = 4;
3645                        end if;
3646                end when;
3647                when time>=3 then
3648                        x = 3;
3649                end when;
3650        end A;
3651       
3652        model B
3653                extends A;
3654        end B;
3655       
3656        B b;
3657
3658        annotation(__JModelica(UnitTesting(tests={
3659                FlatteningTestCase(
3660                        name="WhenInExtendsTest",
3661                        description="",
3662                        flatModel="
3663fclass NameTests.WhenInExtendsTest
3664 discrete Real b.x;
3665 discrete Real b.y;
3666 discrete Integer b.i;
3667 structural parameter Boolean b.b = false /* false */;
3668equation
3669 b.i = 1;
3670 when initial() then
3671  if false then
3672   b.y = 2 + b.i;
3673  else
3674   b.y = 4;
3675  end if;
3676 end when;
3677 when time >= 3 then
3678  b.x = 3;
3679 end when;
3680end NameTests.WhenInExtendsTest;
3681")})));
3682end WhenInExtendsTest;
3683
3684
3685model InheritInputTest1
3686        connector A
3687                Real x;
3688        end A;
3689       
3690        input A a;
3691
3692        annotation(__JModelica(UnitTesting(tests={
3693                FlatteningTestCase(
3694                        name="InheritInputTest1",
3695                        description="Check that input is propagated to child components",
3696                        flatModel="
3697fclass NameTests.InheritInputTest1
3698 input Real a.x;
3699end NameTests.InheritInputTest1;
3700")})));
3701end InheritInputTest1;
3702
3703
3704model InheritInputTest2
3705    connector A
3706        Real x;
3707    end A;
3708       
3709        connector B
3710                A a;
3711        end B;
3712   
3713    input B b;
3714
3715        annotation(__JModelica(UnitTesting(tests={
3716                FlatteningTestCase(
3717                        name="InheritInputTest2",
3718                        description="Check that input is propagated to child components: nested",
3719                        flatModel="
3720fclass NameTests.InheritInputTest2
3721 input Real b.a.x;
3722end NameTests.InheritInputTest2;
3723")})));
3724end InheritInputTest2;
3725
3726
3727model InheritInputTest3
3728    connector A
3729        input Real x;
3730    end A;
3731   
3732    input A a;
3733
3734    annotation(__JModelica(UnitTesting(tests={
3735        ErrorTestCase(
3736            name="InheritInputTest3",
3737            description="Check that it isn't allowed to declare a component containing an input as input",
3738            errorMessage="
37391 errors found:
3740
3741Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3742  Can't declare x as input, since it contains a component declared as input or output
3743")})));
3744end InheritInputTest3;
3745
3746
3747model InheritInputTest4
3748    connector A
3749        output Real x;
3750    end A;
3751   
3752    input A a;
3753
3754    annotation(__JModelica(UnitTesting(tests={
3755        ErrorTestCase(
3756            name="InheritInputTest4",
3757            description="Check that it isn't allowed to declare a component containing an output as input",
3758            errorMessage="
37591 errors found:
3760
3761Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3762  Can't declare x as output, since it contains a component declared as input or output
3763")})));
3764end InheritInputTest4;
3765
3766
3767model InheritOutputTest1
3768    connector A
3769        Real x;
3770    end A;
3771   
3772    output A a;
3773
3774        annotation(__JModelica(UnitTesting(tests={
3775                FlatteningTestCase(
3776                        name="InheritOutputTest1",
3777                        description="Check that output is propagated to child components",
3778                        flatModel="
3779fclass NameTests.InheritOutputTest1
3780 output Real a.x;
3781end NameTests.InheritOutputTest1;
3782")})));
3783end InheritOutputTest1;
3784
3785
3786model InheritOutputTest2
3787    connector A
3788        Real x;
3789    end A;
3790   
3791    connector B
3792        A a;
3793    end B;
3794   
3795    output B b;
3796
3797        annotation(__JModelica(UnitTesting(tests={
3798                FlatteningTestCase(
3799                        name="InheritOutputTest2",
3800                        description="Check that output is propagated to child components: nested",
3801                        flatModel="
3802fclass NameTests.InheritOutputTest2
3803 output Real b.a.x;
3804end NameTests.InheritOutputTest2;
3805")})));
3806end InheritOutputTest2;
3807
3808
3809model InheritOutputTest3
3810    connector A
3811        output Real x;
3812    end A;
3813   
3814    output A a;
3815
3816    annotation(__JModelica(UnitTesting(tests={
3817        ErrorTestCase(
3818            name="InheritOutputTest3",
3819            description="Check that it isn't allowed to declare a component containing an output as output",
3820            errorMessage="
38211 errors found:
3822
3823Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3824  Can't declare x as output, since it contains a component declared as input or output
3825")})));
3826end InheritOutputTest3;
3827
3828
3829model InheritOutputTest4
3830    connector A
3831        input Real x;
3832    end A;
3833   
3834    output A a;
3835
3836    annotation(__JModelica(UnitTesting(tests={
3837        ErrorTestCase(
3838            name="InheritOutputTest4",
3839            description="Check that it isn't allowed to declare a component containing an input as output",
3840            errorMessage="
38411 errors found:
3842
3843Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3844  Can't declare x as input, since it contains a component declared as input or output
3845")})));
3846end InheritOutputTest4;
3847
3848
3849model InheritFlowTest1
3850    connector A
3851        Real x;
3852    end A;
3853
3854    connector B
3855                A ap;
3856        flow A af;
3857        end B;
3858       
3859        B b1, b2;
3860equation
3861        connect(b1, b2);
3862
3863annotation(__JModelica(UnitTesting(tests={
3864    FlatteningTestCase(
3865        name="InheritFlowTest1",
3866        description="Check that flow is propagated to child components",
3867        flatModel="
3868fclass NameTests.InheritFlowTest1
3869 potential Real b1.ap.x;
3870 flow Real b1.af.x;
3871 potential Real b2.ap.x;
3872 flow Real b2.af.x;
3873equation
3874 - b1.af.x - b2.af.x = 0.0;
3875 b1.ap.x = b2.ap.x;
3876 b1.af.x = 0.0;
3877 b2.af.x = 0.0;
3878end NameTests.InheritFlowTest1;
3879")})));
3880end InheritFlowTest1;
3881
3882
3883model InheritFlowTest2
3884    connector A
3885        flow Real x;
3886    end A;
3887   
3888    flow A a;
3889
3890    annotation(__JModelica(UnitTesting(tests={
3891        ErrorTestCase(
3892            name="InheritFlowTest2",
3893            description="Check that it isn't allowed to declare a component containing an flow as flow",
3894            errorMessage="
38951 errors found:
3896
3897Error at line 6, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3898  Can't declare x as flow, since it contains a component declared as flow
3899")})));
3900end InheritFlowTest2;
3901
3902
3903
3904model DuplicateVariables1
3905    model A
3906      Real x(start=1, min=2) = 3;
3907    end A;
3908    extends A;
3909   
3910    Real x(start=1, min=2) = 3;
3911
3912    annotation(__JModelica(UnitTesting(tests={
3913        FlatteningTestCase(
3914            name="DuplicateVariables1",
3915            description="Test that identical components in base classes are handled correctly",
3916            flatModel="
3917fclass NameTests.DuplicateVariables1
3918 Real x(start = 1,min = 2) = 3;
3919end NameTests.DuplicateVariables1;
3920")})));
3921end DuplicateVariables1;
3922
3923
3924model DuplicateVariables2
3925    model A
3926        Real x;
3927    equation
3928        der(x) = time;
3929    end A;
3930   
3931    model B
3932        A a;
3933    end B;
3934   
3935    extends B;
3936    A a;
3937
3938    annotation(__JModelica(UnitTesting(tests={
3939        FlatteningTestCase(
3940            name="DuplicateVariables2",
3941            description="Test that identical components in base classes are handled correctly",
3942            flatModel="
3943fclass NameTests.DuplicateVariables2
3944 Real a.x;
3945equation
3946 der(a.x) = time;
3947end NameTests.DuplicateVariables2;
3948")})));
3949end DuplicateVariables2;
3950
3951
3952model DuplicateVariables3
3953    Real x;
3954    Real x;
3955
3956    annotation(__JModelica(UnitTesting(tests={
3957        ErrorTestCase(
3958            name="DuplicateVariables3",
3959            description="",
3960            errorMessage="
39611 errors found:
3962
3963Error at line 3, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
3964  Duplicate component in same class: Real x
3965")})));
3966end DuplicateVariables3;
3967
3968
3969model DuplicateVariables5
3970    model A
3971      Real x(start=1, min=2) = 3;
3972    end A;
3973   
3974    model B
3975        extends A;
3976        Real x(start=1, min=2) = 3;
3977    end B;
3978   
3979    B b[2];
3980
3981    annotation(__JModelica(UnitTesting(tests={
3982        FlatteningTestCase(
3983            name="DuplicateVariables5",
3984            description="Test that identical components in base classes are handled correctly",
3985            flatModel="
3986fclass NameTests.DuplicateVariables5
3987 Real b[1].x(start = 1,min = 2) = 3;
3988 Real b[2].x(start = 1,min = 2) = 3;
3989end NameTests.DuplicateVariables5;
3990")})));
3991end DuplicateVariables5;
3992
3993
3994model DuplicateVariables6
3995    model A
3996        Real x;
3997        Real x;
3998    end A;
3999   
4000    A a[2];
4001
4002    annotation(__JModelica(UnitTesting(tests={
4003        ErrorTestCase(
4004            name="DuplicateVariables6",
4005            description="",
4006            errorMessage="
40071 errors found:
4008
4009Error at line 4, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo',
4010In component a:
4011  Duplicate component in same class: Real x
4012")})));
4013end DuplicateVariables6;
4014
4015
4016
4017model BadEscape1
4018        parameter String a = "\qabc\ def\nghi\\xjkl\?mno\#";
4019
4020    annotation(__JModelica(UnitTesting(tests={
4021        ErrorTestCase(
4022            name="BadEscape1",
4023            description="Illegal escape sequences in string",
4024            errorMessage="
40253 errors found:
4026
4027Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4028  Illegal escape sequence at position 1 in string: '\\q'
4029
4030Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4031  Illegal escape sequence at position 27 in string: '\\#'
4032
4033Error at line 2, column 23, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4034  Illegal escape sequence at position 6 in string: '\\ '
4035")})));
4036end BadEscape1;
4037
4038
4039model BadEscape2
4040    Real '\qabc\ def\nghi\\xjkl\?mno\#' = 1;
4041        Real x = '\qabc\ def\nghi\\xjkl\?mno\#';
4042
4043    annotation(__JModelica(UnitTesting(tests={
4044        ErrorTestCase(
4045            name="BadEscape2",
4046            description="Illegal escape sequences in quoted identifier",
4047            errorMessage="
40486 errors found:
4049
4050Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4051  Illegal escape sequence at position 2 in quoted identifier: '\\q'
4052
4053Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4054  Illegal escape sequence at position 28 in quoted identifier: '\\#'
4055
4056Error at line 2, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4057  Illegal escape sequence at position 7 in quoted identifier: '\\ '
4058
4059Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4060  Illegal escape sequence at position 2 in quoted identifier: '\\q'
4061
4062Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4063  Illegal escape sequence at position 28 in quoted identifier: '\\#'
4064
4065Error at line 3, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4066  Illegal escape sequence at position 7 in quoted identifier: '\\ '
4067")})));
4068end BadEscape2;
4069
4070
4071model LibWithVerTest1
4072    LibWithVer.Test a;
4073
4074    annotation(__JModelica(UnitTesting(tests={
4075        FlatteningTestCase(
4076            name="LibWithVerTest1",
4077            description="Load library with version # in name",
4078            modelicaLibraries="LibWithVer 1.2",
4079            flatModel="
4080fclass NameTests.LibWithVerTest1
4081 Real a.x = time;
4082end NameTests.LibWithVerTest1;
4083")})));
4084end LibWithVerTest1;
4085
4086
4087model ProtectedComponent1
4088    model A
4089        B b;
4090    protected
4091        Real y = time;
4092    end A;
4093   
4094    model B
4095    protected 
4096        C c;
4097    end B;
4098   
4099    model C
4100        Real x = time;
4101    end C;
4102   
4103    A a;
4104
4105    annotation(__JModelica(UnitTesting(tests={
4106        FlatteningTestCase(
4107            name="ProtectedComponent1",
4108            description="Check that variables in protected components are marked as protected in the flat model",
4109            flatModel="
4110fclass NameTests.ProtectedComponent1
4111protected
4112 Real a.b.c.x = time;
4113 Real a.y = time;
4114end NameTests.ProtectedComponent1;
4115")})));
4116end ProtectedComponent1;
4117
4118
4119model ClassThroughComponent1
4120    model A
4121        package B
4122            constant Real x = 1;
4123        end B;
4124       
4125        parameter Real y = 2;
4126    end A;
4127   
4128    A a;
4129    parameter Real z = a.B.x * a.y;
4130
4131    annotation(__JModelica(UnitTesting(tests={
4132        ErrorTestCase(
4133            name="ClassThroughComponent1",
4134            description="",
4135            errorMessage="
41361 errors found:
4137
4138Error at line 11, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4139  Can not access non-function class through component access: 'a.B.x'
4140")})));
4141end ClassThroughComponent1;
4142
4143
4144model ClassThroughComponent2
4145    model A
4146        package B
4147            constant Real x = 1;
4148        end B;
4149       
4150        parameter Real y = 2;
4151    end A;
4152   
4153    model C
4154        A a;
4155    end C;
4156   
4157    C c;
4158    parameter Real z = c.a.B.x * c.a.y;
4159
4160    annotation(__JModelica(UnitTesting(tests={
4161        ErrorTestCase(
4162            name="ClassThroughComponent2",
4163            description="",
4164            errorMessage="
41651 errors found:
4166
4167Error at line 15, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4168  Can not access non-function class through component access: 'c.a.B.x'
4169")})));
4170end ClassThroughComponent2;
4171
4172
4173model ClassThroughComponent3
4174    model A
4175        package B
4176            constant Real x = 1;
4177        end B;
4178       
4179        parameter Real y = 2;
4180    end A;
4181   
4182    model C
4183        A a[2];
4184    end C;
4185   
4186    C c;
4187    parameter Real z = c.a[1].B.x * c.a[1].y;
4188
4189    annotation(__JModelica(UnitTesting(tests={
4190        ErrorTestCase(
4191            name="ClassThroughComponent3",
4192            description="",
4193            errorMessage="
41941 errors found:
4195
4196Error at line 15, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo', ACCESS_TO_CLASS_THROUGH_COMPONENT:
4197  Can not access non-function class through component access: 'c.a[1].B.x'
4198")})));
4199end ClassThroughComponent3;
4200
4201
4202model ClassThroughComponent4
4203    model A
4204        package B
4205            model C
4206                parameter Real x = 1;
4207            end C;
4208        end B;
4209       
4210        parameter Real y = 2;
4211    end A;
4212   
4213    A a;
4214    a.C c;
4215
4216    annotation(__JModelica(UnitTesting(tests={
4217        ErrorTestCase(
4218            name="ClassThroughComponent4",
4219            description="",
4220            errorMessage="
42211 errors found:
4222
4223Error at line 13, column 5, in file 'Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo':
4224  Cannot find class declaration for a
4225")})));
4226end ClassThroughComponent4;
4227
4228
4229model OrderFile1
4230    extends TestLib.Order.Order1;
4231
4232annotation(__JModelica(UnitTesting(tests={
4233    InstClassMethodTestCase(
4234        name="OrderFile1",
4235        description="Correction of package.order: correct file",
4236        modelicaLibraries="TestLib",
4237        methodName="testOrderHelper",
4238        methodResult="[A, E, B, C, F, D]"
4239)})));
4240end OrderFile1;
4241
4242
4243model OrderFile2
4244    extends TestLib.Order.Order2;
4245
4246annotation(__JModelica(UnitTesting(tests={
4247    InstClassMethodTestCase(
4248        name="OrderFile2",
4249        description="Correction of package.order: package.mo contents in wrong order",
4250        modelicaLibraries="TestLib",
4251        methodName="testOrderHelper",
4252        methodResult="[F, E, A, B, C, D]"
4253)})));
4254end OrderFile2;
4255
4256
4257model OrderFile3
4258    extends TestLib.Order.Order3;
4259
4260annotation(__JModelica(UnitTesting(tests={
4261    InstClassMethodTestCase(
4262        name="OrderFile3",
4263        description="Correction of package.order: class file has wrong case",
4264        modelicaLibraries="TestLib",
4265        methodName="testOrderHelper",
4266        methodResult="[A, B, F, C, D, E]"
4267)})));
4268end OrderFile3;
4269
4270
4271model OrderFile4
4272    extends TestLib.Order.Order4;
4273
4274annotation(__JModelica(UnitTesting(tests={
4275    InstClassMethodTestCase(
4276        name="OrderFile4",
4277        description="Correction of package.order: wrong class names in package.order",
4278        modelicaLibraries="TestLib",
4279        methodName="testOrderHelper",
4280        methodResult="[A, B, C, D, E, F]"
4281)})));
4282end OrderFile4;
4283
4284end NameTests;
Note: See TracBrowser for help on using the repository browser.