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

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

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

File size: 179.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 RedeclareTests
19
20package Basic
21
22model RedeclareTestOx1 "Basic redeclare test"
23 // This is perfectly ok.
24 
25  model A
26    Real x=1;
27  end A;
28 
29  model B
30   Real x=2;
31   Real y=3;
32  end B;
33 
34   model C
35     replaceable A a;
36   end C;
37 
38   C c(redeclare B a);
39 
40
41    annotation(__JModelica(UnitTesting(tests={
42        FlatteningTestCase(
43            name="RedeclareTestOx1",
44            description="Basic redeclares.",
45            flatModel="
46fclass RedeclareTests.Basic.RedeclareTestOx1
47 Real c.a.x = 2;
48 Real c.a.y = 3;
49end RedeclareTests.Basic.RedeclareTestOx1;
50")})));
51end RedeclareTestOx1;
52 
53model RedeclareTestOx2_Err "Basic redeclare test, erroneous"
54  model A
55    Real x=1;
56  end A;
57 
58  model B
59   Real x=2;
60   Real y=3;
61  end B;
62 
63   model C
64     replaceable B b;
65   end C;
66   // Here is the error
67   C c(redeclare A b);
68 
69
70    annotation(__JModelica(UnitTesting(tests={
71        ErrorTestCase(
72            name="RedeclareTestOx2_Err",
73            description="Test basic redeclares. Error caused by failed subtype test in component redeclaration.",
74            errorMessage="
751 errors found:
76
77Error at line 15, column 8, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
78  In the declaration 'redeclare A b', the replacing class is not a subtype of the constraining class from the declaration 'replaceable B b',
79    because y from the constraining type is missing
80")})));
81end RedeclareTestOx2_Err;
82 
83model RedeclareTestOx3 "Redeclare deeper into instance hierarchy."
84
85
86 
87  // Perfectly ok.
88 
89  model A
90    Real x=1;
91  end A;
92 
93  model B
94   Real x=2;
95   Real y=3;
96  end B;
97 
98   model C
99     replaceable A a;
100   end C;
101 
102   model D
103     C c;
104   end D;
105 
106   D d(c(redeclare B a));
107 
108
109    annotation(__JModelica(UnitTesting(tests={
110        FlatteningTestCase(
111            name="RedeclareTestOx3",
112            description="Basic test of redeclares.",
113            flatModel="
114fclass RedeclareTests.Basic.RedeclareTestOx3
115 Real d.c.a.x = 2;
116 Real d.c.a.y = 3;
117end RedeclareTests.Basic.RedeclareTestOx3;
118")})));
119end RedeclareTestOx3;
120 
121model RedeclareTestOx4_Err "Redeclare deeper into instance hierarchy."
122 
123 
124/*
125  Should give an error message like
126  Error in redeclaration in component:
127    D d(c(redeclare A b)) in class RedeclareTestOx4_Err
128   component 'A b' is not a subtype of component 'B b'.
129   Original declaration located in class C.
130   Instance name of original declaration: d.c.b   
131 
132 
133 
134*/
135 
136  model A
137    Real x=1;
138  end A;
139 
140  model B
141   Real x=2;
142   Real y=3;
143  end B;
144 
145   model C
146     replaceable B b;
147   end C;
148 
149   model D
150     C c;
151   end D;
152 
153   D d(c(redeclare A b));
154 
155
156    annotation(__JModelica(UnitTesting(tests={
157        ErrorTestCase(
158            name="RedeclareTestOx4_Err",
159            description="Test basic redeclares. Error caused by failed subtype test in component redeclaration.",
160            errorMessage="
1611 errors found:
162
163Error at line 33, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
164  In the declaration 'redeclare A b', the replacing class is not a subtype of the constraining class from the declaration 'replaceable B b',
165    because y from the constraining type is missing
166")})));
167end RedeclareTestOx4_Err;
168 
169model RedeclareTestOx5 "Redeclare deeper into instance hierarchy and redeclaration of a replacing component."
170  model A
171    Real x=1;
172  end A;
173 
174  model B
175   Real x=2;
176   Real y=3;
177  end B;
178 
179  model C
180   Real x=2;
181   Real y=3;
182   Real z=4;
183  end C;
184 
185   model D
186     replaceable A a;
187   end D;
188 
189   model E
190     D d(redeclare replaceable B a);
191   end E;
192 
193   E e(d(redeclare C a));
194 
195
196    annotation(__JModelica(UnitTesting(tests={
197        FlatteningTestCase(
198            name="RedeclareTestOx5",
199            description="Basic test of redeclares.",
200            flatModel="
201fclass RedeclareTests.Basic.RedeclareTestOx5
202 Real e.d.a.x = 2;
203 Real e.d.a.y = 3;
204 Real e.d.a.z = 4;
205end RedeclareTests.Basic.RedeclareTestOx5;
206")})));
207end RedeclareTestOx5;
208
209
210model RedeclareTestOx6_Err
211  model A
212    Real x=1;
213  end A;
214 
215  model B
216   Real x=2;
217   Real y=3;
218  end B;
219 
220  model C
221   Real x=2;
222   Real y=3;
223   Real z=4;
224  end C;
225 
226   model D
227     replaceable A a;
228   end D;
229 
230   model E
231     D d(redeclare replaceable C a);
232     Real q = d.a.z;
233   end E;
234 
235   E e(d(redeclare B a));
236 
237    annotation(__JModelica(UnitTesting(tests={
238        ErrorTestCase(
239            name="RedeclareTestOx6_Err",
240            description="Redeclare deeper into instance hierarchy and redeclaration of a replacing component",
241            errorMessage="
2421 errors found:
243
244Error at line 23, column 19, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo',
245In component e:
246  Cannot find class or component declaration for z
247")})));
248end RedeclareTestOx6_Err;
249
250 
251model RedeclareTestOx65_Err "Redeclare deeper into instance hierarchy and redeclaration of a replacing component, Errouneous?"
252  model A
253    Real x=1;
254  end A;
255 
256  model B
257   Real x=2;
258   Real y=3;
259  end B;
260 
261  model C
262   Real x=2;
263   Real y=3;
264   Real z=4;
265  end C;
266 
267   model D
268     replaceable B a;
269   end D;
270 
271   model E
272     D d(redeclare replaceable A a);
273   end E;
274 
275   E e(d(redeclare C a)); 
276
277    annotation(__JModelica(UnitTesting(tests={
278        ErrorTestCase(
279            name="RedeclareTestOx65_Err",
280            description="Test basic redeclares. Error caused by failed subtype test in component redeclaration.",
281            errorMessage="
2821 errors found:
283
284Error at line 22, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS,
285In component e:
286  In the declaration 'redeclare replaceable A a', the replacing class is not a subtype of the constraining class from the declaration 'replaceable B a',
287    because y from the constraining type is missing
288")})));
289end RedeclareTestOx65_Err;
290 
291 
292model RedeclareTestOx7_Err
293    "Redeclare deeper into instance hierarchy and redeclaration of a replacing component, Errouneous?"
294  model A
295    Real x=1;
296  end A;
297 
298  model B
299   Real x=2;
300   Real y=3;
301  end B;
302 
303  model C
304   Real x=2;
305   Real y=3;
306   Real z=4;
307  end C;
308 
309   model D
310     replaceable model AA = A;
311     AA a;
312   end D;
313 
314   model E
315     D d(redeclare replaceable model AA=C);
316     Real q = d.a.z; // This should not be ok!
317   end E;
318 
319   E e(d(redeclare model AA=B)); // This redeclaration should be ok since B is a subtype of A!
320 
321    annotation(__JModelica(UnitTesting(tests={
322        ErrorTestCase(
323            name="RedeclareTestOx7_Err",
324            description="Using var not available in final type without explicit constrainedby",
325            errorMessage="
3261 errors found:
327
328Error at line 25, column 19, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo',
329In component e:
330  Cannot find class or component declaration for z
331")})));
332end RedeclareTestOx7_Err;
333 
334model RedeclareTestOx8 "Constraining clause example"
335 
336 
337  model A
338    Real x=1;
339  end A;
340 
341  model B
342   Real x=2;
343   Real y=3;
344  end B;
345 
346  model C
347   Real x=2;
348   Real y=3;
349   Real z=4;
350  end C;
351 
352   model D
353     replaceable C c constrainedby B;
354   end D;
355   // Ok, since the constraining clause of C c is B.
356   D d(redeclare B c);
357 
358
359    annotation(__JModelica(UnitTesting(tests={
360        FlatteningTestCase(
361            name="RedeclareTestOx8",
362            description="Basic test of redeclares.",
363            flatModel="
364fclass RedeclareTests.Basic.RedeclareTestOx8
365 Real d.c.x = 2;
366 Real d.c.y = 3;
367end RedeclareTests.Basic.RedeclareTestOx8;
368")})));
369end RedeclareTestOx8;
370 
371model RedeclareTestOx9_Err "Constraining clause example, errouneous"
372  model A
373    Real x=1;
374  end A;
375 
376  model B
377   Real x=2;
378   Real y=3;
379  end B;
380 
381  model C
382   Real x=2;
383   Real y=3;
384   Real z=4;
385  end C;
386 
387   model D
388     replaceable C c constrainedby B;
389   end D;
390 
391   D d(redeclare A c);
392 
393
394    annotation(__JModelica(UnitTesting(tests={
395        ErrorTestCase(
396            name="RedeclareTestOx9_Err",
397            description="Test basic redeclares. Error caused by failed subtype test in component redeclaration.",
398            errorMessage="
3991 errors found:
400
401Error at line 21, column 8, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
402  In the declaration 'redeclare A c', the replacing class is not a subtype of the constraining class from the declaration 'replaceable C c constrainedby B',
403    because y from the constraining type is missing
404")})));
405end RedeclareTestOx9_Err;
406
407
408model RedeclareTestOx95_Err "Constraining clause example, errouneous"
409  model A
410    Real x=1;
411  end A;
412 
413  model B
414   Real x=2;
415   Real y=3;
416  end B;
417 
418  model C
419   Real x=2;
420   Real y=3;
421   Real z=4;
422  end C;
423 
424   model D
425     replaceable B b constrainedby C;
426   end D;
427 
428   D d;
429 
430
431    annotation(__JModelica(UnitTesting(tests={
432        ErrorTestCase(
433            name="RedeclareTestOx95_Err",
434            description="Check that the declaration is a subtype of the constraining clause",
435            errorMessage="
4361 errors found:
437
438Error at line 18, column 6, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
439  In the declaration 'replaceable B b constrainedby C', the declared class is not a subtype of the constraining class,
440    because z from the constraining type is missing
441")})));
442end RedeclareTestOx95_Err;
443
444
445model RedeclareTestOx10 "Constraining clause example."
446  model A
447    Real x=1;
448  end A;
449 
450  model B
451   Real x=2;
452   Real y=3;
453  end B;
454 
455  model C
456   Real x=2;
457   Real y=3;
458   Real z=4;
459  end C;
460 
461   model D
462     replaceable B c constrainedby B;
463   end D;
464 
465   model E
466     // This is actually ok since the replacing component does not have an
467     // explicit constraining clause, in which case the constraining clause
468     // of the original declaration is used.
469     replaceable D d constrainedby D(redeclare replaceable C c);
470   end E;
471 
472   E e(redeclare D d(redeclare B c));
473 
474
475    annotation(__JModelica(UnitTesting(tests={
476        FlatteningTestCase(
477            name="RedeclareTestOx10",
478            description="Basic test of redeclares.",
479            flatModel="
480fclass RedeclareTests.Basic.RedeclareTestOx10
481 Real e.d.c.x = 2;
482 Real e.d.c.y = 3;
483end RedeclareTests.Basic.RedeclareTestOx10;
484")})));
485end RedeclareTestOx10;
486
487
488model RedeclareTestOx11_Err "Constraining clause example."
489  model A
490    Real x=1;
491  end A;
492 
493  model B
494   Real x=2;
495   Real y=3;
496  end B;
497 
498  model C
499   Real x=2;
500   Real y=3;
501   Real z=4;
502  end C;
503 
504   model D
505     replaceable B c;
506   end D;
507 
508   model E
509     // This is an error
510     replaceable D d constrainedby D(redeclare replaceable B c constrainedby A);
511   end E;
512   
513   // This is another error
514   E e(redeclare D d(redeclare A c));
515
516    annotation(__JModelica(UnitTesting(tests={
517        ErrorTestCase(
518            name="RedeclareTestOx11_Err",
519            description="Check that the declaration is a subtype of the constraining clause",
520            errorMessage="
5211 errors found:
522
523Error at line 23, column 38, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS,
524In component e.d:
525  In the declaration 'redeclare replaceable B c constrainedby A', the replacing class is not a subtype of the constraining class from the declaration 'replaceable B c',
526    because y from the constraining type is missing
527")})));
528end RedeclareTestOx11_Err;
529
530
531model RedeclareTestOx115_Err "Constraining clause example."
532  model A
533    Real x=1;
534  end A;
535 
536  model B
537   Real x=2;
538   Real y=3;
539  end B;
540 
541  model C
542   Real x=2;
543   Real y=3;
544   Real z=4;
545  end C;
546 
547   model D
548     replaceable B c;
549   end D;
550 
551   model E
552     replaceable D d(redeclare replaceable C c constrainedby C) constrainedby D(redeclare replaceable B c constrainedby C);
553   end E;
554
555   E e;
556
557    annotation(__JModelica(UnitTesting(tests={
558        ErrorTestCase(
559            name="RedeclareTestOx115_Err",
560            description="Check that the declaration is a subtype of the constraining clause",
561            errorMessage="
5621 errors found:
563
564Error at line 22, column 81, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS,
565In component e:
566  In the declaration 'redeclare replaceable B c constrainedby C', the declared class is not a subtype of the constraining class,
567    because z from the constraining type is missing
568")})));
569end RedeclareTestOx115_Err;
570
571
572model RedeclareTestOx116_Err "Constraining clause example."
573  model A
574    Real x=1;
575  end A;
576 
577  model B
578   Real x=2;
579   Real y=3;
580  end B;
581 
582  model C
583   Real x=2;
584   Real y=3;
585   Real z=4;
586  end C;
587 
588   model D
589     replaceable B c;
590   end D;
591 
592   model E
593     // This is an error because the constraining clause of C c constrainedby A is not a subtype of B c
594     replaceable D d constrainedby D(redeclare replaceable C c constrainedby A);
595   end E;
596 
597   E e;
598
599    annotation(__JModelica(UnitTesting(tests={
600        ErrorTestCase(
601            name="RedeclareTestOx116_Err",
602            description="Check that the declaration is a subtype of the constraining clause",
603            errorMessage="
6041 errors found:
605
606Error at line 23, column 38, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS,
607In component e:
608  In the declaration 'redeclare replaceable C c constrainedby A', the replacing class is not a subtype of the constraining class from the declaration 'replaceable B c',
609    because y from the constraining type is missing
610")})));
611end RedeclareTestOx116_Err;
612
613
614/* Does not work - the modification of y is reported as an error.*/
615model RedeclareTestOx12 "Constraining clause example."
616 
617  model A
618    Real x=1;
619  end A;
620 
621  model B
622   Real x=2;
623   Real y=3;
624  end B;
625 
626   model D
627     //Here the modifiers (x=3,y=3) are not used when the component is redeclared.
628     replaceable B c(x=3,y=5) constrainedby A(x=5);
629   end D;
630 
631   D d(redeclare A c);
632
633    annotation(__JModelica(UnitTesting(tests={
634        FlatteningTestCase(
635            name="RedeclareTestOx12",
636            description="Check that the declaration is a subtype of the constraining clause",
637            flatModel="
638fclass RedeclareTests.Basic.RedeclareTestOx12
639 Real d.c.x = 5;
640end RedeclareTests.Basic.RedeclareTestOx12;
641")})));
642end RedeclareTestOx12;
643
644
645model RedeclareTestOx121
646    model A
647        Real x;
648    end A;
649   
650    model B
651        extends A;
652        parameter Real y = 1;
653    end B;
654   
655    model C
656        replaceable B a(y = 2) constrainedby A;
657    end C;
658   
659    C c(redeclare A a);
660
661    annotation(__JModelica(UnitTesting(tests={
662        FlatteningTestCase(
663            name="RedeclareTestOx121",
664            description="Modification to parameter that is not available in final component but valid at the point it is added",
665            flatModel="
666fclass RedeclareTests.Basic.RedeclareTestOx121
667 Real c.a.x;
668end RedeclareTests.Basic.RedeclareTestOx121;
669")})));
670end RedeclareTestOx121;
671
672
673model RedeclareTestOx13 "Constraining clause example."
674 
675  model A
676    Real x=1;
677  end A;
678 
679  model B
680   Real x=2;
681   Real y=3;
682  end B;
683 
684  model C
685   Real x=2;
686   Real y=3;
687   Real z=4;
688  end C;
689 
690   model D
691     replaceable A c;
692   end D;
693 
694   model E
695     D d( redeclare replaceable B c(y=10) constrainedby A(x=4));
696   end E;
697 
698   E e(d(redeclare C c(z=5)));
699 
700
701    annotation(__JModelica(UnitTesting(tests={
702        FlatteningTestCase(
703            name="RedeclareTestOx13",
704            description="Check that the declaration is a subtype of the constraining clause",
705            flatModel="
706fclass RedeclareTests.Basic.RedeclareTestOx13
707 Real e.d.c.x = 4;
708 Real e.d.c.y = 3;
709 Real e.d.c.z = 5;
710end RedeclareTests.Basic.RedeclareTestOx13;
711")})));
712end RedeclareTestOx13;
713
714
715model RedeclareTest_Constr_14_Err "Constraining clause example."
716  model A
717    Real x=1;
718  end A;
719 
720  model B
721   Real x=2;
722   Real y=3;
723  end B;
724 
725  model C
726   Real x=2;
727   Real y=3;
728   Real z=4;
729  end C;
730 
731   model D
732     replaceable A c;
733   end D;
734 
735   model E
736     // Here is the error: A is not a subtype of C
737     D d(redeclare replaceable B c constrainedby C);
738   end E;
739 
740   E e(d(redeclare C c));
741 
742
743    annotation(__JModelica(UnitTesting(tests={
744        ErrorTestCase(
745            name="RedeclareTest_Constr_14_Err",
746            description="Check that the declaration is a subtype of the constraining clause",
747            errorMessage="
7481 errors found:
749
750Error at line 23, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS,
751In component e:
752  In the declaration 'redeclare replaceable B c constrainedby C', the declared class is not a subtype of the constraining class,
753    because z from the constraining type is missing
754")})));
755end RedeclareTest_Constr_14_Err;
756
757
758model RedeclareTest_Constr_15_Err "Constraining clause example."
759  model A
760    Real x=1;
761  end A;
762 
763  model B
764   Real x=2;
765   Real y=3;
766  end B;
767 
768  model C
769   Real x=2;
770   Real y=3;
771   Real z=4;
772  end C;
773 
774   model D
775     replaceable A c;
776   end D;
777 
778   model E
779     // Here is the error: B is not a subtype of C
780     D d(redeclare replaceable B c constrainedby C);
781   end E;
782 
783   E e(d(redeclare replaceable C c));
784
785    annotation(__JModelica(UnitTesting(tests={
786        ErrorTestCase(
787            name="RedeclareTest_Constr_15_Err",
788            description="Check that the declaration is a subtype of the constraining clause",
789            errorMessage="
7901 errors found:
791
792Error at line 23, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS,
793In component e:
794  In the declaration 'redeclare replaceable B c constrainedby C', the declared class is not a subtype of the constraining class,
795    because z from the constraining type is missing
796")})));
797end RedeclareTest_Constr_15_Err;
798
799
800model RedeclareTest_Constr_16_Err "Constraining clause example."
801  model A
802    Real x=1;
803  end A;
804 
805  model B
806   Real x=2;
807   Real y=3;
808  end B;
809 
810  model C
811   Real x=2;
812   Real y=3;
813   Real z=4;
814  end C;
815 
816   model D
817     replaceable A c;
818   end D;
819 
820   model E
821     // Here is the error: B is not a subtype of C
822     D d(redeclare replaceable B c constrainedby B);
823   end E;
824 
825   E e(d(redeclare replaceable A c));
826
827    annotation(__JModelica(UnitTesting(tests={
828        ErrorTestCase(
829            name="RedeclareTest_Constr_16_Err",
830            description="Check that the declaration is a subtype of the constraining clause",
831            errorMessage="
8321 errors found:
833
834Error at line 26, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
835  In the declaration 'redeclare replaceable A c', the replacing class is not a subtype of the constraining class from the declaration 'redeclare replaceable B c constrainedby B',
836    because y from the constraining type is missing
837")})));
838end RedeclareTest_Constr_16_Err;
839
840
841model RedeclareTest_Constr_17_Err "Constraining clause example."
842  model A
843    Real x=1;
844  end A;
845 
846  model B
847   Real x=2;
848   Real y=3;
849  end B;
850 
851  model C
852   Real x=2;
853   Real y=3;
854   Real z=4;
855  end C;
856 
857   model D
858     replaceable A c;
859   end D;
860 
861   model E
862     replaceable D d(redeclare replaceable B c constrainedby B);
863   end E;
864 
865   // Here is the error: B is not a subtype of C
866   E e(redeclare replaceable D d(redeclare replaceable B c) constrainedby D(redeclare replaceable C c constrainedby C));
867
868    annotation(__JModelica(UnitTesting(tests={
869        ErrorTestCase(
870            name="RedeclareTest_Constr_17_Err",
871            description="Check that the declaration is a subtype of the constraining clause",
872            errorMessage="
8732 errors found:
874
875Error at line 26, column 8, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
876  In the declaration 'redeclare replaceable D d(redeclare replaceable B c) constrainedby D (redeclare replaceable C c constrainedby C)', the declared class is not a subtype of the constraining class,
877    because c.z from the constraining type is missing
878
879Error at line 26, column 34, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
880  In the declaration 'redeclare replaceable B c', the replacing class is not a subtype of the constraining class from the declaration 'redeclare replaceable C c constrainedby C',
881    because z from the constraining type is missing
882")})));
883end RedeclareTest_Constr_17_Err;
884
885
886model RedeclareTest_Constr_18_Err "Constraining clause example."
887  model A
888    Real x=1;
889  end A;
890 
891  model B
892   Real x=2;
893   Real y=3;
894  end B;
895 
896  model C
897   Real x=2;
898   Real y=3;
899   Real z=4;
900  end C;
901 
902   model D
903     replaceable C c constrainedby C;
904   end D;
905 
906   model E
907     // Notice that the modifier in the constraining clause is applied to the declaration itself
908     // and is therefore type checked.
909     replaceable D d constrainedby D(redeclare replaceable B c);
910   end E;
911 
912   E e;
913
914    annotation(__JModelica(UnitTesting(tests={
915        ErrorTestCase(
916            name="RedeclareTest_Constr_18_Err",
917            description="Check that the declaration is a subtype of the constraining clause",
918            errorMessage="
9192 errors found:
920
921Error at line 24, column 6, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
922  In the declaration 'replaceable D d constrainedby D (redeclare replaceable B c)', the declared class is not a subtype of the constraining class,
923    because c.z from the constraining type is missing
924
925Error at line 24, column 38, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS,
926In component e:
927  In the declaration 'redeclare replaceable B c', the replacing class is not a subtype of the constraining class from the declaration 'replaceable C c constrainedby C',
928    because z from the constraining type is missing
929")})));
930end RedeclareTest_Constr_18_Err;
931
932
933model RedeclareTest_Classes_1 "Redeclaration of classes example."
934  model A
935    Real x=1;
936  end A;
937 
938  model B
939   Real x=2;
940   Real y=3;
941  end B;
942 
943  model C
944   Real x=2;
945   Real y=3;
946   Real z=4;
947  end C;
948 
949   model D
950     replaceable model myA = A;
951     myA a(x=4);
952   end D;
953 
954   model E
955      D d(redeclare replaceable model myA = C);
956   end E;
957 
958   E e;
959
960    annotation(__JModelica(UnitTesting(tests={
961        FlatteningTestCase(
962            name="RedeclareTest_Classes_1",
963            description="Test of parametrized classes.",
964            flatModel="
965fclass RedeclareTests.Basic.RedeclareTest_Classes_1
966 Real e.d.a.x = 4;
967 Real e.d.a.y = 3;
968 Real e.d.a.z = 4;
969end RedeclareTests.Basic.RedeclareTest_Classes_1;
970")})));
971end RedeclareTest_Classes_1;
972
973
974model RedeclareTestOx6b_Err
975 model A
976    Real x=1;
977 end A;
978 
979  model B
980   Real x=2;
981   Real y=3;
982  end B;
983 
984   model D
985     replaceable A a;
986   end D;
987 
988   model E
989     D d(redeclare replaceable B a constrainedby B);
990     Real q = d.a.y; // This access should not be ok since y is not part of
991                     // the constraining interface of the replacing
992                     // component B b. The constraining interface of the
993                     // replacing component B b is rather defined by the
994                     // original declaration A a.
995   end E;
996 
997   // This is a perfectly legal redeclare, since the constraining class of
998   // the replacing declaration B a is A a
999   E e(d(redeclare A a));
1000 
1001end RedeclareTestOx6b_Err;
1002
1003
1004end Basic;
1005
1006
1007package General
1008
1009model RedeclareTest0
1010  model A
1011    Real x;
1012  end A;
1013 
1014  model B
1015   Real x;
1016   Real y;
1017  end B;
1018 
1019  model B2
1020   Real x;
1021   Real y;
1022   Real z;
1023  end B2;
1024
1025 
1026   model C
1027     replaceable A a;
1028   end C;
1029   
1030   model D
1031     C c(redeclare B a);
1032   end D;
1033   
1034   D d(c(redeclare B2 a));
1035   
1036 
1037
1038end RedeclareTest0;
1039
1040
1041
1042model RedeclareTest1
1043 
1044 
1045  model C2
1046    Real x=2;
1047  end C2;
1048 
1049  model C22
1050    Real x=3;
1051    Real y=4;
1052  end C22;
1053 
1054  model C222
1055    Real x=5;
1056    Real y=6;
1057    Real z=7;
1058  end C222;
1059 
1060  model A
1061    replaceable C2 c2;
1062  end A;
1063 
1064  model B
1065    // Notice that the modifier 'x=8' is not merged since
1066    // it redeclared and since there is no constraining clause 
1067    A a(redeclare replaceable C22 c2(x=8));
1068    A aa;
1069  end B;
1070 
1071  A a(redeclare C22 c2);
1072  B b(a(redeclare C222 c2(z=9,y=4)));
1073
1074        annotation(__JModelica(UnitTesting(tests={
1075                FlatteningTestCase(
1076                        name="RedeclareTest1",
1077                        description="Basic redeclares.",
1078                        flatModel="
1079 fclass RedeclareTests.General.RedeclareTest1
1080 Real a.c2.x = 3 /*(3)*/;
1081 Real a.c2.y = 4 /*(4)*/;
1082 Real b.a.c2.x = 5 /*(5)*/;
1083 Real b.a.c2.y = 4 /*(4)*/;
1084 Real b.a.c2.z = 9 /*(9)*/;
1085 Real b.aa.c2.x = 2 /*(2)*/;
1086end RedeclareTests.General.RedeclareTest1;
1087")})));
1088end RedeclareTest1;
1089
1090
1091model RedeclareTest2
1092 
1093 
1094  model Color
1095    Real r=0;
1096    Real g=0;
1097    Real b=0;
1098  end Color;
1099 
1100  model Red
1101    extends Color(r=1);
1102  end Red;
1103 
1104  model Green
1105    extends Color(g=1);
1106  end Green;
1107 
1108  model Blue
1109    extends Color(b=1);
1110  end Blue;
1111 
1112  model Palette
1113     replaceable Color c1;
1114     replaceable Color c2;
1115     replaceable Color c3;
1116  end Palette;
1117 
1118  Palette p(redeclare Red c1(r=1,g=0.1,b=0.1),redeclare Blue c2,redeclare Green c3);
1119 
1120
1121        annotation(__JModelica(UnitTesting(tests={
1122                FlatteningTestCase(
1123                        name="RedeclareTest2",
1124                        description="Basic redeclares.",
1125                        flatModel="
1126/*
1127fclass RedeclareTests.General.RedeclareTest2;
1128  Real p.c1.r = 1;
1129  Real p.c1.g = 0.1;
1130  Real p.c1.b = 0.1;
1131  Real p.c2.r = 0;
1132  Real p.c2.g = 0;
1133  Real p.c2.b = 1;
1134  Real p.c3.r = 0;
1135  Real p.c3.g = 1;
1136  Real p.c3.b = 0;
1137end RedeclareTests.General.RedeclareTest2;
1138*/
1139fclass RedeclareTests.General.RedeclareTest2
1140 Real p.c1.r = 1 /*(1)*/;
1141 Real p.c1.g = 0.1 /*(0.1)*/;
1142 Real p.c1.b = 0.1 /*(0.1)*/;
1143 Real p.c2.r = 0 /*(0)*/;
1144 Real p.c2.g = 0 /*(0)*/;
1145 Real p.c2.b = 1 /*(1)*/;
1146 Real p.c3.r = 0 /*(0)*/;
1147 Real p.c3.g = 1 /*(1)*/;
1148 Real p.c3.b = 0 /*(0)*/;
1149end RedeclareTests.General.RedeclareTest2;
1150")})));
1151end RedeclareTest2;
1152
1153model RedeclareTest3
1154 
1155 
1156 
1157  extends C0.Colors.MyPalette(p(redeclare C0.Colors.Green c3(r=0.56,g=0.85,b=0.24),c1(b=0.23)));
1158model C0
1159   
1160  model Colors
1161  model Color
1162    Real rr = 0;
1163    Real r=rr;
1164    Real g=0;
1165    Real b=0;
1166  end Color;
1167     
1168  model Red
1169    extends Color(r=1);
1170  end Red;
1171     
1172  model Green
1173    extends Color(g=gg);
1174    Real gg = 1; 
1175  end Green;
1176     
1177  model Blue
1178    extends Color(b=1);
1179  end Blue;
1180     
1181  model Palette
1182     Real b = 0.001;
1183     replaceable Color c1;
1184     replaceable Color c2;
1185     replaceable Color c3(b=b);
1186     Real q = 0.4;
1187  end Palette;
1188     
1189  model MyPalette
1190       
1191  Real q = 0.3;
1192       
1193  Palette p(redeclare replaceable Red c1(g=0.1,b=q),redeclare replaceable Blue c2,
1194            redeclare replaceable Green c3(b=0.002));
1195       
1196  end MyPalette;
1197     
1198  end Colors;
1199   
1200end C0;
1201 
1202  Real r = 0.1;
1203 C0.Colors.MyPalette palette(p(c3(r=r),redeclare C0.Colors.Red c1(g=0.2)));
1204 
1205
1206        annotation(__JModelica(UnitTesting(tests={
1207                FlatteningTestCase(
1208                        name="RedeclareTest3",
1209                        description="Basic redeclares.",
1210                        flatModel="
1211fclass RedeclareTests.General.RedeclareTest3
1212 Real r = 0.1 /*(0.1)*/;
1213 Real palette.q = 0.3 /*(0.3)*/;
1214 Real palette.p.b = 0.0010 /*(0.0010)*/;
1215 Real palette.p.c1.rr = 0 /*(0)*/;
1216 Real palette.p.c1.r = 1 /*(1)*/;
1217 Real palette.p.c1.g = 0.2 /*(0.2)*/;
1218 Real palette.p.c1.b = 0 /*(0)*/;
1219 Real palette.p.c2.rr = 0 /*(0)*/;
1220 Real palette.p.c2.r = palette.p.c2.rr;
1221 Real palette.p.c2.g = 0 /*(0)*/;
1222 Real palette.p.c2.b = 1 /*(1)*/;
1223 Real palette.p.c3.gg = 1 /*(1)*/;
1224 Real palette.p.c3.rr = 0 /*(0)*/;
1225 Real palette.p.c3.r = r;
1226 Real palette.p.c3.g = palette.p.c3.gg;
1227 Real palette.p.c3.b = 0.0020 /*(0.0020)*/;
1228 Real palette.p.q = 0.4 /*(0.4)*/;
1229 Real q = 0.3 /*(0.3)*/;
1230 Real p.b = 0.0010 /*(0.0010)*/;
1231 Real p.c1.rr = 0 /*(0)*/;
1232 Real p.c1.r = 1 /*(1)*/;
1233 Real p.c1.g = 0.1 /*(0.1)*/;
1234 Real p.c1.b = 0.23 /*(0.23)*/;
1235 Real p.c2.rr = 0 /*(0)*/;
1236 Real p.c2.r = p.c2.rr;
1237 Real p.c2.g = 0 /*(0)*/;
1238 Real p.c2.b = 1 /*(1)*/;
1239 Real p.c3.gg = 1 /*(1)*/;
1240 Real p.c3.rr = 0 /*(0)*/;
1241 Real p.c3.r = 0.56 /*(0.56)*/;
1242 Real p.c3.g = 0.85 /*(0.85)*/;
1243 Real p.c3.b = 0.24 /*(0.24)*/;
1244 Real p.q = 0.4 /*(0.4)*/;
1245end RedeclareTests.General.RedeclareTest3;
1246")})));
1247end RedeclareTest3;
1248
1249
1250model RedeclareTest4
1251   
1252 
1253  extends C0(p(redeclare C0.Green c3(r=0.56,g=0.85,b=0.24),c1(b=0.23)));
1254model C0
1255 
1256 
1257  model Color
1258    Real r=0;
1259    Real g=0;
1260    Real b=0;
1261  end Color;
1262 
1263  model Red
1264    extends Color(r=1);
1265  end Red;
1266 
1267  model Green
1268    extends Color(g=1);
1269  end Green;
1270 
1271  model Blue
1272    extends Color(b=1);
1273  end Blue;
1274 
1275  model Palette
1276     replaceable Color c1;
1277     replaceable Color c2;
1278     replaceable Color c3(b=0.001);
1279  end Palette;
1280 
1281  Real q = 0.3;
1282 
1283  Palette p(redeclare replaceable Red c1(g=0.1,b=q),redeclare replaceable Blue c2,redeclare replaceable Green c3);
1284 
1285end C0;
1286
1287 C0 c0(p(c3(r=0.1),redeclare C0.Red c1(g=0.2)));
1288
1289 
1290
1291
1292        annotation(__JModelica(UnitTesting(tests={
1293                FlatteningTestCase(
1294                        name="RedeclareTest4",
1295                        description="Basic redeclares.",
1296                        flatModel="
1297fclass RedeclareTests.General.RedeclareTest4
1298 Real c0.q = 0.3 /*(0.3)*/;
1299 Real c0.p.c1.r = 1 /*(1)*/;
1300 Real c0.p.c1.g = 0.2 /*(0.2)*/;
1301 Real c0.p.c1.b = 0 /*(0)*/;
1302 Real c0.p.c2.r = 0 /*(0)*/;
1303 Real c0.p.c2.g = 0 /*(0)*/;
1304 Real c0.p.c2.b = 1 /*(1)*/;
1305 Real c0.p.c3.r = 0.1 /*(0.1)*/;
1306 Real c0.p.c3.g = 1 /*(1)*/;
1307 Real c0.p.c3.b = 0.0010 /*(0.0010)*/;
1308 Real q = 0.3 /*(0.3)*/;
1309 Real p.c1.r = 1 /*(1)*/;
1310 Real p.c1.g = 0.1 /*(0.1)*/;
1311 Real p.c1.b = 0.23 /*(0.23)*/;
1312 Real p.c2.r = 0 /*(0)*/;
1313 Real p.c2.g = 0 /*(0)*/;
1314 Real p.c2.b = 1 /*(1)*/;
1315 Real p.c3.r = 0.56 /*(0.56)*/;
1316 Real p.c3.g = 0.85 /*(0.85)*/;
1317 Real p.c3.b = 0.24 /*(0.24)*/;
1318end RedeclareTests.General.RedeclareTest4;
1319")})));
1320end RedeclareTest4;
1321
1322
1323model RedeclareTest5
1324 
1325 
1326
1327
1328model Unnamed
1329  model C1
1330    model C2
1331      Real x=2;
1332    end C2;
1333    replaceable C2 c2(x=4);
1334  end C1;
1335   
1336  model C22
1337     Real x=1;
1338     Real y=3;
1339  end C22;
1340   
1341  model C222
1342    Real x=11;
1343     Real y=33;
1344  end C222;
1345   
1346  C1 c1(redeclare replaceable C222 c2(y=44,x=2));
1347   
1348end Unnamed;
1349 
1350model C222
1351     Real x=2;
1352     Real y=4;
1353     Real z=6;
1354end C222;
1355 Unnamed u(c1(redeclare C222 c2(x=55,z=66)));
1356
1357
1358        annotation(__JModelica(UnitTesting(tests={
1359                FlatteningTestCase(
1360                        name="RedeclareTest5",
1361                        description="Basic redeclares.",
1362                        flatModel="
1363fclass RedeclareTests.General.RedeclareTest5
1364 Real u.c1.c2.x = 55 /*(55)*/;
1365 Real u.c1.c2.y = 4 /*(4)*/;
1366 Real u.c1.c2.z = 66 /*(66)*/;
1367end RedeclareTests.General.RedeclareTest5;
1368")})));
1369end RedeclareTest5;
1370
1371model RedeclareTest6
1372  model C2
1373    Real x=2;
1374  end C2;
1375 
1376  model C22
1377    Real x=3;
1378    Real y=4;
1379  end C22;
1380 
1381  model C222
1382    Real x=5;
1383    Real y=6;
1384    Real z=7;
1385  end C222;
1386 
1387  model A
1388    replaceable C2 c2(x=55); 
1389  end A;
1390 
1391  model B
1392    A a(redeclare replaceable C22 c2(y=8));
1393  end B;
1394 
1395  B b(a(redeclare C222 c2(z=9,y=4,x=6)));
1396  B bb;
1397
1398
1399        annotation(__JModelica(UnitTesting(tests={
1400                FlatteningTestCase(
1401                        name="RedeclareTest6",
1402                        description="Basic redeclares.",
1403                        flatModel="
1404fclass RedeclareTests.General.RedeclareTest6
1405 Real b.a.c2.x = 6 /*(6)*/;
1406 Real b.a.c2.y = 4 /*(4)*/;
1407 Real b.a.c2.z = 9 /*(9)*/;
1408 Real bb.a.c2.x = 55 /*(55)*/;
1409 Real bb.a.c2.y = 8 /*(8)*/;
1410end RedeclareTests.General.RedeclareTest6;
1411")})));
1412end RedeclareTest6;
1413
1414
1415model RedeclareTest7
1416  model A
1417        model B
1418        Real x=3;
1419                end B;
1420        model C
1421        Real x=4;
1422        Real y=5;
1423        end C;
1424        model D
1425          replaceable B b(x=0);
1426        end D;
1427        D d(b(x=7));
1428  end A;
1429  Real p=4;
1430  A a(d(redeclare A.C b(x=p)));
1431
1432        annotation(__JModelica(UnitTesting(tests={
1433                FlatteningTestCase(
1434                        name="RedeclareTest7",
1435                        description="Basic redeclares.",
1436                        flatModel="
1437fclass RedeclareTests.General.RedeclareTest7
1438 Real p = 4 /*(4)*/;
1439 Real a.d.b.x = p;
1440 Real a.d.b.y = 5 /*(5)*/;
1441end RedeclareTests.General.RedeclareTest7;
1442")})));
1443end RedeclareTest7;
1444
1445model RedeclareTest8
1446 
1447  model C2
1448    Real x=2;
1449   
1450   
1451  end C2;
1452 
1453  model C22
1454    Real x=3;
1455    Real y=4;
1456    Real w=5;
1457  end C22;
1458 
1459  model C222
1460    Real x=5;
1461    Real y=6;
1462                Real w=4;
1463    Real z=7;
1464  end C222;
1465 
1466  model A
1467    Real q = 1;
1468    replaceable C2 c2;
1469  end A;
1470 
1471  model B
1472    Real p =1;
1473    A a(redeclare replaceable C22 c2(x=8,y=10),q=2);
1474    A a1(redeclare replaceable C22 c2(x=p));
1475    A aa;
1476  end B;
1477 
1478  A a(redeclare C22 c2);
1479  B b(a(redeclare C222 c2(z=9,y=4)));
1480end RedeclareTest8;
1481
1482model RedeclareTest9
1483 
1484 
1485  model C2
1486    Real x=2;
1487  end C2;
1488 
1489  model C22
1490    Real x=3;
1491    Real y=4;
1492  end C22;
1493 
1494  model C222
1495    Real x=5;
1496    Real y=6;
1497    Real z=7;
1498  end C222;
1499 
1500  model A
1501    replaceable C2 c2;
1502  end A;
1503 
1504  model B
1505    // Note that the modifier 'x=8' is  merged since
1506    // it appears in a constraining clause 
1507    A a(redeclare replaceable C22 c2 constrainedby C22(x=8));
1508    A aa;
1509  end B;
1510 
1511  A a(redeclare C22 c2);
1512  B b(a(redeclare C222 c2(z=9,y=4)));
1513
1514        annotation(__JModelica(UnitTesting(tests={
1515                FlatteningTestCase(
1516                        name="RedeclareTest9",
1517                        description="Basic redeclares.",
1518                        flatModel="
1519 fclass RedeclareTests.General.RedeclareTest9
1520 Real a.c2.x = 3 /*(3)*/;
1521 Real a.c2.y = 4 /*(4)*/;
1522 Real b.a.c2.x = 8 /*(8)*/;
1523 Real b.a.c2.y = 4 /*(4)*/;
1524 Real b.a.c2.z = 9 /*(9)*/;
1525 Real b.aa.c2.x = 2 /*(2)*/;
1526end RedeclareTests.General.RedeclareTest9;
1527")})));
1528end RedeclareTest9;
1529
1530model RedeclareTest95_Err
1531 
1532 
1533  model C2
1534    Real x=2;
1535  end C2;
1536 
1537  model C22
1538    Real x=3;
1539    Real y=4;
1540  end C22;
1541 
1542  model C222
1543    Real x=5;
1544    Real y=6;
1545    Real z=7;
1546  end C222;
1547 
1548  model A
1549    replaceable C2 c2;
1550  end A;
1551 
1552  model B
1553    // Note that the modifier 'w=8' is  merged since
1554    // it appears in a constraining clause 
1555    A a(redeclare replaceable C22 c2 constrainedby C22(w=8));
1556    A aa;
1557  end B;
1558 
1559  A a(redeclare C22 c2);
1560  B b(a(redeclare C222 c2(z=9,y=4)));
1561
1562    annotation(__JModelica(UnitTesting(tests={
1563        ErrorTestCase(
1564            name="RedeclareTest95_Err",
1565            description="Basic redeclares.",
1566            errorMessage="
15671 errors found:
1568
1569Error at line 26, column 56, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo',
1570In component b:
1571  Cannot find component declaration for w
1572")})));
1573end RedeclareTest95_Err;
1574
1575
1576model RedeclareTest97_Err
1577  model C2
1578    Real x=2;
1579  end C2;
1580 
1581  model C22
1582    Real x=3;
1583    Real y=4;
1584  end C22;
1585 
1586  model C222
1587    Real x=5;
1588    Real y=6;
1589    Real z=7;
1590  end C222;
1591 
1592  model A
1593    replaceable C2 c2;
1594  end A;
1595 
1596  model B
1597    // Note that the modifier 'w=8' is  merged since
1598    // it appears in a constraining clause 
1599    extends A(redeclare replaceable C22 c2 constrainedby C22(w=8));
1600    A aa;
1601  end B;
1602 
1603  A a(redeclare C22 c2);
1604  B b(redeclare C222 c2(z=9,y=4));
1605
1606    annotation(__JModelica(UnitTesting(tests={
1607        ErrorTestCase(
1608            name="RedeclareTest97_Err",
1609            description="Basic redeclares.",
1610            errorMessage="
16111 errors found:
1612
1613Error at line 24, column 62, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo',
1614In component b:
1615  Cannot find component declaration for w
1616")})));
1617end RedeclareTest97_Err;
1618
1619model RedeclareTest10
1620 
1621  extends C0.Colors.MyPalette(p(redeclare C0.Colors.Green c3(r=0.56,g=0.85,b=0.24),c1(b=0.23)));
1622model C0
1623   
1624  model Colors
1625  model Color
1626    Real rr = 0;
1627    Real r=rr;
1628    Real g=0;
1629    Real b=0;
1630  end Color;
1631     
1632  model Red
1633    extends Color(r=1);
1634  end Red;
1635     
1636  model Green
1637    extends Color(g=gg);
1638    Real gg = 1; 
1639  end Green;
1640     
1641  model Blue
1642    extends Color(b=1);
1643  end Blue;
1644     
1645  model Palette
1646     Real b = 0.001;
1647     replaceable Color c1;
1648     replaceable Color c2;
1649     replaceable Color c3(b=b);
1650     Real q = 0.4;
1651  end Palette;
1652     
1653  model MyPalette
1654       
1655  Real q = 0.3;
1656       
1657  Palette p(redeclare replaceable Red c1 constrainedby Red(g=0.1,b=q),redeclare replaceable Blue c2,
1658            redeclare replaceable Green c3 constrainedby Green(b=0.002));
1659       
1660  end MyPalette;
1661     
1662  end Colors;
1663   
1664end C0;
1665 
1666  Real r = 0.1;
1667 C0.Colors.MyPalette palette(p(c3(r=r),redeclare C0.Colors.Red c1(g=0.2)));
1668 
1669
1670        annotation(__JModelica(UnitTesting(tests={
1671                FlatteningTestCase(
1672                        name="RedeclareTest10",
1673                        description="Basic redeclares.",
1674                        flatModel="
1675fclass RedeclareTests.General.RedeclareTest10
1676 Real r = 0.1 /*(0.1)*/;
1677 Real palette.q = 0.3 /*(0.3)*/;
1678 Real palette.p.b = 0.0010 /*(0.0010)*/;
1679 Real palette.p.c1.rr = 0 /*(0)*/;
1680 Real palette.p.c1.r = 1 /*(1)*/;
1681 Real palette.p.c1.g = 0.2 /*(0.2)*/;
1682 Real palette.p.c1.b = palette.q;
1683 Real palette.p.c2.rr = 0 /*(0)*/;
1684 Real palette.p.c2.r = palette.p.c2.rr;
1685 Real palette.p.c2.g = 0 /*(0)*/;
1686 Real palette.p.c2.b = 1 /*(1)*/;
1687 Real palette.p.c3.gg = 1 /*(1)*/;
1688 Real palette.p.c3.rr = 0 /*(0)*/;
1689 Real palette.p.c3.r = r;
1690 Real palette.p.c3.g = palette.p.c3.gg;
1691 Real palette.p.c3.b = 0.0020 /*(0.0020)*/;
1692 Real palette.p.q = 0.4 /*(0.4)*/;
1693 Real q = 0.3 /*(0.3)*/;
1694 Real p.b = 0.0010 /*(0.0010)*/;
1695 Real p.c1.rr = 0 /*(0)*/;
1696 Real p.c1.r = 1 /*(1)*/;
1697 Real p.c1.g = 0.1 /*(0.1)*/;
1698 Real p.c1.b = 0.23 /*(0.23)*/;
1699 Real p.c2.rr = 0 /*(0)*/;
1700 Real p.c2.r = p.c2.rr;
1701 Real p.c2.g = 0 /*(0)*/;
1702 Real p.c2.b = 1 /*(1)*/;
1703 Real p.c3.gg = 1 /*(1)*/;
1704 Real p.c3.rr = 0 /*(0)*/;
1705 Real p.c3.r = 0.56 /*(0.56)*/;
1706 Real p.c3.g = 0.85 /*(0.85)*/;
1707 Real p.c3.b = 0.24 /*(0.24)*/;
1708 Real p.q = 0.4 /*(0.4)*/;
1709end RedeclareTests.General.RedeclareTest10;
1710")})));
1711end RedeclareTest10;
1712
1713model RedeclareTest11
1714   
1715 
1716  extends C0(p(redeclare replaceable C0.Green c3 constrainedby C0.Green(r=0.56,g=0.85,b=0.24),c1(b=0.23)));
1717model C0
1718 
1719 
1720  model Color
1721    Real r=0;
1722    Real g=0;
1723    Real b=0;
1724  end Color;
1725 
1726  model Red
1727    extends Color(r=1);
1728  end Red;
1729 
1730  model Green
1731    extends Color(g=1);
1732  end Green;
1733 
1734  model Blue
1735    extends Color(b=1);
1736  end Blue;
1737 
1738  model Palette
1739     replaceable Color c1;
1740     replaceable Color c2;
1741     replaceable Color c3(b=0.001);
1742  end Palette;
1743 
1744  Real q = 0.3;
1745 
1746  Palette p(redeclare replaceable Red c1 constrainedby Red(g=0.1,b=q),
1747            redeclare replaceable Blue c2,redeclare replaceable Green c3);
1748 
1749end C0;
1750
1751 C0 c0(p(c3(r=0.1),redeclare C0.Red c1(g=0.2)));
1752
1753 
1754
1755
1756        annotation(__JModelica(UnitTesting(tests={
1757                FlatteningTestCase(
1758                        name="RedeclareTest11",
1759                        description="Basic redeclares.",
1760                        flatModel="
1761fclass RedeclareTests.General.RedeclareTest11
1762 Real c0.q = 0.3 /*(0.3)*/;
1763 Real c0.p.c1.r = 1 /*(1)*/;
1764 Real c0.p.c1.g = 0.2 /*(0.2)*/;
1765 Real c0.p.c1.b = c0.q;
1766 Real c0.p.c2.r = 0 /*(0)*/;
1767 Real c0.p.c2.g = 0 /*(0)*/;
1768 Real c0.p.c2.b = 1 /*(1)*/;
1769 Real c0.p.c3.r = 0.1 /*(0.1)*/;
1770 Real c0.p.c3.g = 1 /*(1)*/;
1771 Real c0.p.c3.b = 0.0010 /*(0.0010)*/;
1772 Real q = 0.3 /*(0.3)*/;
1773 Real p.c1.r = 1 /*(1)*/;
1774 Real p.c1.g = 0.1 /*(0.1)*/;
1775 Real p.c1.b = 0.23 /*(0.23)*/;
1776 Real p.c2.r = 0 /*(0)*/;
1777 Real p.c2.g = 0 /*(0)*/;
1778 Real p.c2.b = 1 /*(1)*/;
1779 Real p.c3.r = 0.56 /*(0.56)*/;
1780 Real p.c3.g = 0.85 /*(0.85)*/;
1781 Real p.c3.b = 0.24 /*(0.24)*/;
1782end RedeclareTests.General.RedeclareTest11;
1783")})));
1784end RedeclareTest11;
1785
1786model RedeclareTest12
1787 
1788 
1789
1790
1791model Unnamed
1792  model C1
1793    model C2
1794      Real x=2;
1795    end C2;
1796    replaceable C2 c2(x=4);
1797  end C1;
1798   
1799  model C22
1800     Real x=1;
1801     Real y=3;
1802  end C22;
1803   
1804  model C222
1805    Real x=11;
1806     Real y=33;
1807  end C222;
1808   
1809  C1 c1(redeclare replaceable C222 c2 constrainedby C222(y=44,x=2));
1810   
1811end Unnamed;
1812 
1813model C222
1814     Real x=2;
1815     Real y=4;
1816     Real z=6;
1817end C222;
1818 Unnamed u(c1(redeclare C222 c2(x=55,z=66)));
1819
1820
1821        annotation(__JModelica(UnitTesting(tests={
1822                FlatteningTestCase(
1823                        name="RedeclareTest12",
1824                        description="Basic redeclares.",
1825                        flatModel="
1826fclass RedeclareTests.General.RedeclareTest12
1827 Real u.c1.c2.x = 55 /*(55)*/;
1828 Real u.c1.c2.y = 44 /*(44)*/;
1829 Real u.c1.c2.z = 66 /*(66)*/;
1830end RedeclareTests.General.RedeclareTest12;
1831")})));
1832end RedeclareTest12;
1833
1834model RedeclareTest13
1835
1836        model A
1837          Real x=1;
1838          Real y=2;
1839        end A;
1840       
1841        model B
1842          extends A;
1843          Real z = 3;
1844        end B;
1845       
1846        model C
1847          replaceable B b1(x=5) constrainedby B(x=3,y=4);
1848          replaceable B b2(x=5) constrainedby B(y=3);
1849    end C;
1850   
1851    C c;
1852       
1853
1854        annotation(__JModelica(UnitTesting(tests={
1855                FlatteningTestCase(
1856                        name="RedeclareTest13",
1857                        description="Basic redeclares.",
1858                        flatModel="
1859fclass RedeclareTests.General.RedeclareTest13
1860 Real c.b1.z = 3 /*(3)*/;
1861 Real c.b1.x = 5 /*(5)*/;
1862 Real c.b1.y = 4 /*(4)*/;
1863 Real c.b2.z = 3 /*(3)*/;
1864 Real c.b2.x = 5 /*(5)*/;
1865 Real c.b2.y = 3 /*(3)*/;
1866end RedeclareTests.General.RedeclareTest13;
1867")})));
1868end RedeclareTest13;
1869
1870model RedeclareTest14
1871        model A
1872          Real x=1;
1873          Real y=2;
1874        end A;
1875       
1876        model B
1877          extends A;
1878          Real z = 3;
1879        end B;
1880       
1881        model C
1882          replaceable B b1(x=5) constrainedby B(x=3,y=4);
1883          replaceable B b2(x=5) constrainedby B(y=3);
1884    end C;
1885   
1886    C c(redeclare B b2(z=5));
1887       
1888
1889        annotation(__JModelica(UnitTesting(tests={
1890                FlatteningTestCase(
1891                        name="RedeclareTest14",
1892                        description="Basic redeclares.",
1893                        flatModel="
1894fclass RedeclareTests.General.RedeclareTest14
1895 Real c.b1.z = 3 /*(3)*/;
1896 Real c.b1.x = 5 /*(5)*/;
1897 Real c.b1.y = 4 /*(4)*/;
1898 Real c.b2.z = 5 /*(5)*/;
1899 Real c.b2.x = 1 /*(1)*/;
1900 Real c.b2.y = 3 /*(3)*/;
1901end RedeclareTests.General.RedeclareTest14;
1902")})));
1903end RedeclareTest14;
1904
1905class RedeclareTest15 "Test of merging of modifications in parametrized classes"
1906 
1907 
1908  model A
1909    Real x=1;
1910  end A;
1911 
1912  model B
1913   Real x=2;
1914   Real y=3;
1915  end B;
1916 
1917   model C
1918     replaceable model myA = A(x=2);
1919     myA a(x=4);
1920   end C;
1921 
1922   model D
1923      C c(redeclare replaceable model myA = B(y=5));
1924   end D;
1925 
1926   D d;
1927
1928
1929        annotation(__JModelica(UnitTesting(tests={
1930                FlatteningTestCase(
1931                        name="RedeclareTest15",
1932                        description="Test of parametrized classes.",
1933                        flatModel="
1934fclass RedeclareTests.General.RedeclareTest15
1935 Real d.c.a.x = 4 /*(4)*/;
1936 Real d.c.a.y = 5 /*(5)*/;
1937end RedeclareTests.General.RedeclareTest15;
1938")})));
1939end RedeclareTest15;
1940
1941class RedeclareTest16 "Test of merging of modifications in parametrized classes"
1942 
1943 
1944  model A
1945    Real x=1;
1946  end A;
1947 
1948  model B
1949   Real x=2;
1950   Real y=3;
1951  end B;
1952 
1953  model C
1954   Real x=2;
1955   Real y=3;
1956   Real z=4;
1957  end C;
1958
1959   model D
1960     replaceable A a(x=4);
1961   
1962   end D;
1963 
1964   model E
1965     replaceable model myB = B(x=6,y=4);
1966     D d(redeclare replaceable myB a(x=5));
1967   end E;
1968 
1969   E e(redeclare model myB = C(z=6));
1970
1971
1972        annotation(__JModelica(UnitTesting(tests={
1973                FlatteningTestCase(
1974                        name="RedeclareTest16",
1975                        description="Test of parametrized classes.",
1976                        flatModel="
1977fclass RedeclareTests.General.RedeclareTest16
1978 Real e.d.a.x = 5 /*(5)*/;
1979 Real e.d.a.y = 4 /*(4)*/;
1980 Real e.d.a.z = 6 /*(6)*/;
1981end RedeclareTests.General.RedeclareTest16;
1982")})));
1983end RedeclareTest16;
1984
1985class RedeclareTest161 "Test of merging of modifications in parametrized classes"
1986 
1987 
1988  model A
1989    Real x=1;
1990  end A;
1991 
1992  model B
1993   Real x=2;
1994   Real y=3;
1995  end B;
1996 
1997  model C
1998   Real x=2;
1999   Real y=3;
2000   Real z=4;
2001  end C;
2002
2003   model E
2004     replaceable model myB = B(x=6,y=4);
2005     extends myB;
2006   end E;
2007 
2008   E e(redeclare model myB = C(z=6));
2009
2010
2011        annotation(__JModelica(UnitTesting(tests={
2012                FlatteningTestCase(
2013                        name="RedeclareTest161",
2014                        description="Test of parametrized classes.",
2015                        flatModel="
2016fclass RedeclareTests.General.RedeclareTest161
2017 Real e.x = 6 /*(6)*/;
2018 Real e.y = 4 /*(4)*/;
2019 Real e.z = 6 /*(6)*/;
2020end RedeclareTests.General.RedeclareTest161;
2021")})));
2022end RedeclareTest161;
2023
2024class RedeclareTest165
2025 
2026 
2027  model A
2028    Real x=1;
2029  end A;
2030 
2031  model B
2032   Real x=2;
2033   Real y=3;
2034   Real z=4;
2035   Real u=5;
2036   Real v=6;
2037  end B;
2038 
2039  model C
2040   Real x=2;
2041   Real y=3;
2042   Real z=4;
2043   Real u=5;
2044   Real v=6;
2045   Real w=7;
2046  end C;
2047 
2048   model D
2049     replaceable A a(x=4);
2050 
2051   end D;
2052 
2053   model E
2054     parameter Real pE = 5;
2055     replaceable model myB = BB(x=6,y=pE); // This access to B should be illegal since
2056                                           // Redeclare165 is not a package.
2057     D d(redeclare replaceable myB a(x=5));
2058   end E;
2059 
2060   model BB = B(u=1); // This is tricky. Notice that 'u=1' is inside BB and is
2061                      // handled as such when modifications are merged. In this
2062                      // case it means that it is discarded when myB is redeclared.
2063 
2064   E e(redeclare model myB = C(z=6));
2065 
2066
2067        annotation(__JModelica(UnitTesting(tests={
2068                FlatteningTestCase(
2069                        name="RedeclareTest165",
2070                        description="Test of parametrized classes.",
2071                        flatModel="
2072fclass RedeclareTests.General.RedeclareTest165
2073 parameter Real e.pE = 5 /*(5)*/;
2074 Real e.d.a.x = 5 /*(5)*/;
2075 Real e.d.a.y = e.pE /*(5)*/;
2076 Real e.d.a.z = 6 /*(6)*/;
2077 Real e.d.a.u = 5 /*(5)*/;
2078 Real e.d.a.v = 6 /*(6)*/;
2079 Real e.d.a.w = 7 /*(7)*/;
2080end RedeclareTests.General.RedeclareTest165;
2081")})));
2082end RedeclareTest165;
2083
2084model RedeclareTest17
2085 
2086   
2087 
2088   package P
2089   model A
2090    Real x=1;
2091   end A;
2092 
2093     model B
2094        Real x=2;
2095        Real y=3;
2096     end B;
2097 
2098     model C
2099        Real x=2;
2100        Real y=3;
2101        Real z=4;
2102     end C;
2103     
2104     replaceable model BB = B(x=3);
2105   end P;
2106 
2107   package PP = P(redeclare model BB = P.C(y=5));
2108 
2109  PP.BB bb(y=3);
2110 
2111
2112        annotation(__JModelica(UnitTesting(tests={
2113                FlatteningTestCase(
2114                        name="RedeclareTest17",
2115                        description="Test of parametrized classes.",
2116                        flatModel="
2117fclass RedeclareTests.General.RedeclareTest17
2118 Real bb.x = 3 /*(3)*/;
2119 Real bb.y = 3 /*(3)*/;
2120 Real bb.z = 4 /*(4)*/;
2121end RedeclareTests.General.RedeclareTest17;
2122
2123")})));
2124end RedeclareTest17;
2125
2126model RedeclareTest175
2127 
2128   
2129   package P
2130   model A
2131    Real x=1;
2132   end A;
2133 
2134     model B
2135        Real x=2;
2136        Real y=3;
2137     end B;
2138 
2139     model C
2140        Real x=2;
2141        Real y=3;
2142        Real z=4;
2143     end C;
2144     
2145     replaceable model BB
2146        extends B(x=3);
2147     end BB;
2148   end P;
2149 
2150   package PP = P(redeclare model BB = P.C(z=5));
2151 
2152  PP.BB bb(y=6);
2153 
2154
2155        annotation(__JModelica(UnitTesting(tests={
2156                FlatteningTestCase(
2157                        name="RedeclareTest175",
2158                        description="Test of parametrized classes.",
2159                        flatModel="
2160fclass RedeclareTests.General.RedeclareTest175
2161 Real bb.x = 2 /*(2)*/;
2162 Real bb.y = 6 /*(6)*/;
2163 Real bb.z = 5 /*(5)*/;
2164end RedeclareTests.General.RedeclareTest175;
2165
2166")})));
2167end RedeclareTest175;
2168
2169model RedeclareTest176
2170 
2171   
2172   package P
2173   model A
2174    Real x=1;
2175   end A;
2176 
2177     model B
2178        Real x=2;
2179        Real y=3;
2180     end B;
2181 
2182     model C
2183        Real x=2;
2184        Real y=3;
2185        Real z=4;
2186     end C;
2187     
2188     replaceable model BB = B(x=3);
2189     
2190   end P;
2191 
2192   package PP = P(redeclare model BB
2193                              extends P.C(y=4);
2194                            end BB);
2195 
2196  PP.BB bb(y=6);
2197 
2198
2199        annotation(__JModelica(UnitTesting(tests={
2200                FlatteningTestCase(
2201                        name="RedeclareTest176",
2202                        description="Test of parametrized classes.",
2203                        flatModel="
2204fclass RedeclareTests.General.RedeclareTest176
2205 Real bb.x = 3 /*(3)*/;
2206 Real bb.y = 6 /*(6)*/;
2207 Real bb.z = 4 /*(4)*/;
2208end RedeclareTests.General.RedeclareTest176;
2209
2210")})));
2211end RedeclareTest176;
2212
2213
2214model RedeclareTest18 "Test of merging of modifications in parametrized classes"
2215  model A
2216    Real x=1;
2217  end A;
2218 
2219  model B
2220   Real x=2;
2221   Real y=3;
2222  end B;
2223 
2224  model C
2225   Real x=2;
2226   Real y=3;
2227   Real z=4;
2228  end C;
2229
2230  model D
2231   Real x=2;
2232   Real y=3;
2233   Real z=4;
2234   Real w=5;
2235  end D;
2236
2237   model E
2238     replaceable A a(x=4);
2239   
2240   end E;
2241 
2242   model F
2243     replaceable model myB = B(x=6,y=4);
2244     E e(redeclare replaceable myB a(x=5));
2245   end F;
2246 
2247   model G
2248     replaceable model myC = C(y=7,z=4);
2249     F f(redeclare model myB = myC);
2250   end G;
2251   
2252   G g(redeclare model myC = D(z=6,w=5));
2253
2254        annotation(__JModelica(UnitTesting(tests={
2255                FlatteningTestCase(
2256                        name="RedeclareTest18",
2257                        description="Test of parametrized classes.",
2258                        flatModel="
2259fclass RedeclareTests.General.RedeclareTest18
2260 Real g.f.e.a.x = 5 /*(5)*/;
2261 Real g.f.e.a.y = 4 /*(4)*/;
2262 Real g.f.e.a.z = 6 /*(6)*/;
2263 Real g.f.e.a.w = 5 /*(5)*/;
2264end RedeclareTests.General.RedeclareTest18;
2265")})));
2266end RedeclareTest18;
2267
2268class RedeclareTest19 "Test of merging of modifications in parametrized classes"
2269 
2270 
2271  model A
2272    Real x=1;
2273  end A;
2274 
2275  model B
2276   Real x=2;
2277   Real y=3;
2278  end B;
2279 
2280  model C
2281   Real x=2;
2282   Real y=3;
2283   Real z=4;
2284  end C;
2285
2286  model D
2287   Real x=2;
2288   Real y=3;
2289   Real z=4;
2290   Real w=5;
2291  end D;
2292
2293   model E
2294     replaceable A a(x=4);
2295   
2296   end E;
2297 
2298   model F
2299     replaceable model myB = B(x=6,y=4);
2300     E e(redeclare replaceable myB a(x=5));
2301   end F;
2302 
2303   model G
2304     replaceable model myC = C(y=7,z=4);
2305     model myC2 = myC(y=10);
2306     F f(redeclare model myB = myC2);
2307   end G;
2308   
2309   
2310   G g(redeclare model myC = D(z=6,w=5));
2311
2312
2313        annotation(__JModelica(UnitTesting(tests={
2314                FlatteningTestCase(
2315                        name="RedeclareTest19",
2316                        description="Test of parametrized classes.",
2317                        flatModel="
2318fclass RedeclareTests.General.RedeclareTest19
2319 Real g.f.e.a.x = 5 /*(5)*/;
2320 Real g.f.e.a.y = 4 /*(4)*/;
2321 Real g.f.e.a.z = 6 /*(6)*/;
2322 Real g.f.e.a.w = 5 /*(5)*/;
2323end RedeclareTests.General.RedeclareTest19;
2324")})));
2325end RedeclareTest19;
2326
2327class RedeclareTest20 "Test of merging of modifications in parametrized classes"
2328 
2329 
2330  model A
2331    Real x=1;
2332  end A;
2333 
2334  model B
2335   Real x=2;
2336   Real y=3;
2337  end B;
2338 
2339  model C
2340   Real x=2;
2341   Real y=3;
2342   Real z=4;
2343  end C;
2344
2345  model D
2346   Real x=2;
2347   Real y=3;
2348   Real z=4;
2349   Real w=5;
2350  end D;
2351
2352   model E
2353   
2354     model myB = B(x=5);
2355     myB b;
2356     replaceable A a(x=4);
2357   
2358   end E;
2359 
2360   model F
2361     replaceable model myB = B(x=6,y=4);
2362     E e(redeclare replaceable myB a(x=5));
2363   end F;
2364 
2365   model G
2366     replaceable model myC = C(y=7,z=4);
2367     model myC2 = myC(y=10);
2368     F f(redeclare model myB = myC2);
2369   end G;
2370   
2371   G g(redeclare model myC = D(z=6,w=5));
2372
2373
2374        annotation(__JModelica(UnitTesting(tests={
2375                FlatteningTestCase(
2376                        name="RedeclareTest20",
2377                        description="Test of parametrized classes.",
2378                        flatModel="
2379fclass RedeclareTests.General.RedeclareTest20
2380 Real g.f.e.b.x = 5 /*(5)*/;
2381 Real g.f.e.b.y = 3 /*(3)*/;
2382 Real g.f.e.a.x = 5 /*(5)*/;
2383 Real g.f.e.a.y = 4 /*(4)*/;
2384 Real g.f.e.a.z = 6 /*(6)*/;
2385 Real g.f.e.a.w = 5 /*(5)*/;
2386end RedeclareTests.General.RedeclareTest20;
2387       
2388")})));
2389end RedeclareTest20;
2390
2391class RedeclareTest21 "Test of merging of modifications in parametrized classes"
2392 
2393 
2394  model A
2395    Real x=1;
2396  end A;
2397 
2398  model B
2399   Real x=2;
2400   Real y=3;
2401  end B;
2402 
2403  model C
2404   Real x=2;
2405   Real y=3;
2406   Real z=4;
2407  end C;
2408
2409  model D
2410   Real x=2;
2411   Real y=3;
2412   Real z=4;
2413   Real w=5;
2414  end D;
2415
2416   model E
2417     parameter Real pE = 3;
2418     model myB = B(x=pE);
2419     myB b;
2420     replaceable A a(x=4);
2421   
2422   end E;
2423 
2424   model F
2425     parameter Real pF = 4;
2426     replaceable model myB = B(x=6,y=pF);
2427     E e(redeclare replaceable myB a(x=5));
2428   end F;
2429 
2430   model G
2431         parameter Real pG = 6;
2432     replaceable model myC = C(y=7,z=pG);
2433     model myC2 = myC(y=10);
2434     F f(redeclare model myB = myC2);
2435   end G;
2436   
2437   parameter Real p0 = 5; 
2438   G g(redeclare model myC = D(w=p0));
2439
2440
2441        annotation(__JModelica(UnitTesting(tests={
2442                FlatteningTestCase(
2443                        name="RedeclareTest21",
2444                        description="Test of parametrized classes.",
2445                        flatModel="
2446fclass RedeclareTests.General.RedeclareTest21
2447 parameter Real p0 = 5 /*(5)*/;
2448 parameter Real g.pG = 6 /*(6)*/;
2449 parameter Real g.f.pF = 4 /*(4)*/;
2450 parameter Real g.f.e.pE = 3 /*(3)*/;
2451 Real g.f.e.b.x = g.f.e.pE /*(3)*/;
2452 Real g.f.e.b.y = 3 /*(3)*/;
2453 Real g.f.e.a.x = 5 /*(5)*/;
2454 Real g.f.e.a.y = g.f.pF /*(4)*/;
2455 Real g.f.e.a.z = g.pG /*(6)*/;
2456 Real g.f.e.a.w = p0 /*(5)*/;
2457end RedeclareTests.General.RedeclareTest21;     
2458")})));
2459end RedeclareTest21;
2460
2461class RedeclareTest22 "Test of merging of modifications in parametrized classes"
2462 
2463 
2464  model A
2465    Real x=1;
2466  end A;
2467 
2468  model B
2469   Real x=2;
2470   Real y=3;
2471  end B;
2472 
2473  model C
2474   Real x=2;
2475   Real y=3;
2476   Real z=4;
2477  end C;
2478
2479  model D
2480   Real x=2;
2481   Real y=3;
2482   Real z=4;
2483   Real w=5;
2484  end D;
2485
2486   model E
2487     parameter Real pE = 3;
2488     replaceable model myB = B(x=pE);
2489     myB b;
2490   end E;
2491 
2492   model F
2493     parameter Real pF = 4;
2494     replaceable model myB2 = B(x=6,y=pF);
2495     E e(redeclare model myB = myB2);
2496   end F;
2497 
2498   model G
2499         parameter Real pG = 6;
2500     replaceable model myC = C(y=7,z=pG);
2501     F f(e(redeclare model myB = myC));
2502   end G;
2503   
2504   parameter Real p0 = 5; 
2505   G g(f(e(redeclare model myB = D(w=p0))));
2506
2507
2508        annotation(__JModelica(UnitTesting(tests={
2509                FlatteningTestCase(
2510                        name="RedeclareTest22",
2511                        description="Test of parametrized classes.",
2512                        flatModel="
2513fclass RedeclareTests.General.RedeclareTest22
2514 parameter Real p0 = 5 /*(5)*/;
2515 parameter Real g.pG = 6 /*(6)*/;
2516 parameter Real g.f.pF = 4 /*(4)*/;
2517 parameter Real g.f.e.pE = 3 /*(3)*/;
2518 Real g.f.e.b.x = g.f.e.pE /*(3)*/;
2519 Real g.f.e.b.y = 3 /*(3)*/;
2520 Real g.f.e.b.z = 4 /*(4)*/;
2521 Real g.f.e.b.w = p0 /*(5)*/;
2522end RedeclareTests.General.RedeclareTest22;
2523")})));
2524end RedeclareTest22;
2525
2526class RedeclareTest225 "Test of merging of modifications in parametrized classes"
2527 
2528 
2529  model A
2530    Real x=1;
2531  end A;
2532 
2533  model B
2534   Real x=2;
2535   Real y=3;
2536  end B;
2537 
2538  model C
2539   Real x=2;
2540   Real y=3;
2541   Real z=4;
2542  end C;
2543
2544  model D
2545   Real x=2;
2546   Real y=3;
2547   Real z=4;
2548   Real w=5;
2549  end D;
2550
2551   model E
2552     parameter Real pE = 3;
2553     replaceable model myB = B(x=pE);
2554     myB b;
2555   end E;
2556 
2557   model F
2558     E e;
2559   end F;
2560 
2561   parameter Real p0 = 5; 
2562   F f(e(redeclare model myB = D(w=p0)));
2563
2564
2565        annotation(__JModelica(UnitTesting(tests={
2566                FlatteningTestCase(
2567                        name="RedeclareTest225",
2568                        description="Test of parametrized classes.",
2569                        flatModel="
2570fclass RedeclareTests.General.RedeclareTest225
2571 parameter Real p0 = 5 /*(5)*/;
2572 parameter Real f.e.pE = 3 /*(3)*/;
2573 Real f.e.b.x = f.e.pE /*(3)*/;
2574 Real f.e.b.y = 3 /*(3)*/;
2575 Real f.e.b.z = 4 /*(4)*/;
2576 Real f.e.b.w = p0 /*(5)*/;
2577end RedeclareTests.General.RedeclareTest225;   
2578")})));
2579end RedeclareTest225;
2580
2581model RedeclareTest23
2582
2583
2584  model B
2585     Real x=2;
2586     Real y=3;
2587  end B;
2588
2589  model C
2590     Real x=2;
2591     Real y=3;
2592     Real z=4;
2593  end C;
2594
2595  model D
2596    replaceable model BB = B(x=4);
2597    BB b;
2598  end D;
2599
2600  model CC = C(x=5,z=10);
2601
2602  model CCC
2603     extends C(x=5,z=10);
2604  end CCC;
2605
2606
2607  D d1(redeclare model BB = CC);
2608  D d2(redeclare model BB = CCC);
2609 
2610
2611
2612        annotation(__JModelica(UnitTesting(tests={
2613                FlatteningTestCase(
2614                        name="RedeclareTest23",
2615                        description="Test of parametrized classes.",
2616                        flatModel="
2617fclass RedeclareTests.General.RedeclareTest23
2618 Real d1.b.x = 4 /*(4)*/;
2619 Real d1.b.y = 3 /*(3)*/;
2620 Real d1.b.z = 10 /*(10)*/;
2621 Real d2.b.x = 4 /*(4)*/;
2622 Real d2.b.y = 3 /*(3)*/;
2623 Real d2.b.z = 10 /*(10)*/;
2624end RedeclareTests.General.RedeclareTest23;
2625
2626")})));
2627end RedeclareTest23;
2628
2629class RedeclareTest24 "Test of merging of modifications in parametrized classes"
2630 
2631 
2632  model A
2633    Real x=1;
2634  end A;
2635 
2636  model B
2637   Real x=2;
2638   Real y=3;
2639  end B;
2640 
2641  model C
2642   Real x=2;
2643   Real y=3;
2644   Real z=4;
2645  end C;
2646
2647  model D
2648   Real x=2;
2649   Real y=3;
2650   Real z=4;
2651   Real w=5;
2652  end D;
2653
2654   model E
2655     parameter Real pE = 3;
2656     replaceable model myB = B(x=pE);
2657     myB b;
2658   end E;
2659 
2660   model F
2661     parameter Real pF = 4;
2662     replaceable model myB2 = B(x=6,y=pF);
2663     E e(redeclare model myB = myB2(y=8));
2664   end F;
2665 
2666   model G
2667         parameter Real pG = 6;
2668     replaceable model myC = C(y=7,z=pG);
2669     F f(e(redeclare model myB = myC(z=9)));
2670   end G;
2671   
2672   parameter Real p0 = 5; 
2673   G g(f(e(redeclare model myB = D(w=p0))));
2674
2675
2676        annotation(__JModelica(UnitTesting(tests={
2677                FlatteningTestCase(
2678                        name="RedeclareTest24",
2679                        description="Test of parametrized classes.",
2680                        flatModel="
2681fclass RedeclareTests.General.RedeclareTest24
2682 parameter Real p0 = 5 /*(5)*/;
2683 parameter Real g.pG = 6 /*(6)*/;
2684 parameter Real g.f.pF = 4 /*(4)*/;
2685 parameter Real g.f.e.pE = 3 /*(3)*/;
2686 Real g.f.e.b.x = g.f.e.pE /*(3)*/;
2687 Real g.f.e.b.y = 3 /*(3)*/;
2688 Real g.f.e.b.z = 4 /*(4)*/;
2689 Real g.f.e.b.w = p0 /*(5)*/;
2690end RedeclareTests.General.RedeclareTest24;
2691")})));
2692end RedeclareTest24;
2693
2694class RedeclareTest25 "Test of merging of modifications in parametrized classes"
2695 
2696 
2697  model A
2698    Real x=1;
2699  end A;
2700 
2701  model B
2702   Real x=2;
2703   Real y=3;
2704  end B;
2705 
2706  model C
2707   Real x=2;
2708   Real y=3;
2709   Real z=4;
2710  end C;
2711
2712  model D
2713   Real x=2;
2714   Real y=3;
2715   Real z=4;
2716   Real w=5;
2717  end D;
2718
2719   model E
2720     parameter Real pE = 3;
2721     replaceable model myB = B(x=pE);
2722     myB b;
2723   end E;
2724 
2725   model F
2726     parameter Real pF = 4;
2727     replaceable model myB2 = B(x=6,y=pF);
2728     E e(redeclare replaceable model myB = myB2 constrainedby myB2(y=8));
2729   end F;
2730 
2731   model G
2732         parameter Real pG = 6;
2733     replaceable model myC = C(y=7,z=pG);
2734     F f(e(redeclare replaceable model myB = myC constrainedby myC(z=9)));
2735   end G;
2736   
2737   parameter Real p0 = 5; 
2738   G g(f(e(redeclare model myB = D(w=p0))));
2739
2740
2741        annotation(__JModelica(UnitTesting(tests={
2742                FlatteningTestCase(
2743                        name="RedeclareTest25",
2744                        description="Test of parametrized classes.",
2745                        flatModel="
2746fclass RedeclareTests.General.RedeclareTest25
2747 parameter Real p0 = 5 /*(5)*/;
2748 parameter Real g.pG = 6 /*(6)*/;
2749 parameter Real g.f.pF = 4 /*(4)*/;
2750 parameter Real g.f.e.pE = 3 /*(3)*/;
2751 Real g.f.e.b.x = g.f.e.pE /*(3)*/;
2752 Real g.f.e.b.y = 8 /*(8)*/;
2753 Real g.f.e.b.z = 9 /*(9)*/;
2754 Real g.f.e.b.w = p0 /*(5)*/;
2755end RedeclareTests.General.RedeclareTest25;
2756")})));
2757end RedeclareTest25;
2758
2759model RedeclareTest26
2760
2761       
2762        model M1
2763          Real x;
2764          model Q
2765            Real z;
2766          end Q;
2767        end M1;
2768       
2769        model M2
2770          Real x;
2771          Real y;
2772          model Q
2773            Real z;
2774          end Q;
2775        end M2;
2776       
2777        model A
2778           replaceable M1 m;
2779        end A;
2780
2781    extends A(redeclare M2 m);
2782
2783
2784        annotation(__JModelica(UnitTesting(tests={
2785                FlatteningTestCase(
2786                        name="RedeclareTest26",
2787                        description="Test of parametrized classes.",
2788                        flatModel="
2789fclass RedeclareTests.General.RedeclareTest26
2790 Real m.x;
2791 Real m.y;
2792end RedeclareTests.General.RedeclareTest26;
2793")})));
2794end RedeclareTest26;
2795
2796model RedeclareTest27
2797 
2798 package P1
2799    model A
2800      Real x=2;
2801    end A;
2802  end P1;
2803
2804  package P2
2805    extends P1;
2806    model B
2807      Real y=3;
2808    end B;
2809  end P2;
2810
2811  package P3
2812    replaceable package P = P1;
2813  end P3;
2814
2815  package P4
2816    extends P3(redeclare package P = P2);
2817  end P4;
2818
2819  P4.P.B b;
2820
2821
2822
2823        annotation(__JModelica(UnitTesting(tests={
2824                FlatteningTestCase(
2825                        name="RedeclareTest27",
2826                        description="Test of parametrized classes.",
2827                        flatModel="
2828fclass RedeclareTests.General.RedeclareTest27
2829 Real b.y = 3;
2830end RedeclareTests.General.RedeclareTest27;
2831")})));
2832end RedeclareTest27;
2833
2834model RedeclareTest28
2835
2836
2837
2838  model M1
2839    parameter Real p1=2;
2840  end M1;
2841
2842  model M2
2843    extends M1;
2844    parameter Real p2=2;
2845  end M2;
2846
2847  model A
2848    parameter Real p3 = 1;
2849    replaceable M1 m1(p1=p3);
2850  end A;
2851 
2852  parameter Real p2 = 3;
2853  extends A(redeclare M2 m1(p2=p2));
2854
2855
2856
2857        annotation(__JModelica(UnitTesting(tests={
2858                FlatteningTestCase(
2859                        name="RedeclareTest28",
2860                        description="Test of parametrized classes.",
2861                        flatModel="
2862fclass RedeclareTests.General.RedeclareTest28
2863 parameter Real p2 = 3 /* 3.0 */;
2864 parameter Real p3 = 1 /* 1.0 */;
2865 parameter Real m1.p2 = p2;
2866 parameter Real m1.p1 = p3;
2867end RedeclareTests.General.RedeclareTest28;
2868")})));
2869end RedeclareTest28;
2870
2871
2872model RedeclareTest29
2873    record A
2874        parameter Integer n;
2875        Real x[n];
2876    end A;
2877   
2878    package B
2879        constant A a;
2880    end B;
2881   
2882    package C
2883        extends B(a(n=2, x={1,2}));
2884    end C;
2885   
2886    Real y[2] = C.a.x;
2887
2888        annotation(__JModelica(UnitTesting(tests={
2889                FlatteningTestCase(
2890                        name="RedeclareTest29",
2891                        description="Modifying parameter that is used as size of array",
2892                        flatModel="
2893fclass RedeclareTests.General.RedeclareTest29
2894 Real y[2] = {1.0,2.0};
2895end RedeclareTests.General.RedeclareTest29;
2896")})));
2897end RedeclareTest29;
2898
2899
2900model RedeclareTest30
2901    model A
2902        Real x;
2903    end A;
2904   
2905    model B
2906        extends A;
2907        parameter Real y = 2;
2908    equation
2909        x = y;
2910    end B;
2911   
2912    replaceable B a constrainedby A;
2913
2914        annotation(__JModelica(UnitTesting(tests={
2915                FlatteningTestCase(
2916                        name="RedeclareTest30",
2917                        description="Test that constrainedby does not prevent accesses within same class",
2918                        flatModel="
2919fclass RedeclareTests.General.RedeclareTest30
2920 parameter Real a.y = 2 /* 2 */;
2921 Real a.x;
2922equation
2923 a.x = a.y;
2924end RedeclareTests.General.RedeclareTest30;
2925")})));
2926end RedeclareTest30;
2927
2928
2929model RedeclareTest31
2930    model A
2931        Real x;
2932    end A;
2933   
2934    model B
2935        extends A;
2936        parameter Real y = 2;
2937    end B;
2938   
2939    replaceable B a constrainedby A;
2940equation
2941        a.x = a.y;
2942
2943    annotation(__JModelica(UnitTesting(tests={
2944        WarningTestCase(
2945            name="RedeclareTest31",
2946            description="Test that constrainedby prevents accesses to elements not in constraining class from outside component",
2947            errorMessage="
29481 warnings found:
2949
2950Warning at line 13, column 10, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE:
2951  Access to component y not recommended, it is not present in constraining type of declaration 'replaceable B a constrainedby A'
2952")})));
2953end RedeclareTest31;
2954
2955
2956model RedeclareTest32
2957        package A
2958                constant Real x = 1;
2959        end A;
2960       
2961        model B
2962                replaceable package C
2963                        constant Real x = 2;
2964                end C;
2965               
2966                Real y = C.x;
2967        end B;
2968       
2969        model D
2970                extends B(redeclare package C = E);
2971        end D;
2972       
2973        package E
2974                constant Real x = 3;
2975        end E;
2976       
2977        D[2] d;
2978
2979        annotation(__JModelica(UnitTesting(tests={
2980                TransformCanonicalTestCase(
2981                        name="RedeclareTest32",
2982                        description="Lookup of extends with redeclare modification in array",
2983            eliminate_alias_variables=false,
2984                        flatModel="
2985fclass RedeclareTests.General.RedeclareTest32
2986 constant Real d[1].y = 3.0;
2987 constant Real d[2].y = 3.0;
2988end RedeclareTests.General.RedeclareTest32;
2989")})));
2990end RedeclareTest32;
2991
2992
2993model RedeclareTest33
2994        model A
2995                replaceable Boolean a;
2996                Real x = if a then time else -time;
2997        end A;
2998       
2999        A a(redeclare Boolean a = time < 3);
3000
3001        annotation(__JModelica(UnitTesting(tests={
3002                FlatteningTestCase(
3003                        name="RedeclareTest33",
3004                        description="Replacing primitive variable",
3005                        flatModel="
3006fclass RedeclareTests.General.RedeclareTest33
3007 discrete Boolean a.a = time < 3;
3008 Real a.x = if a.a then time else - time;
3009end RedeclareTests.General.RedeclareTest33;
3010")})));
3011end RedeclareTest33;
3012
3013
3014model RedeclareTest34
3015    record A
3016        parameter Real a = 1;
3017        replaceable parameter B b;
3018    end A;
3019
3020    record B
3021        parameter Real c = 2;
3022    end B;
3023
3024    record C
3025        extends A(a = 3, redeclare parameter D b(c = 4));
3026    end C;
3027               
3028    record D
3029        extends B(c = 5);
3030    end D;
3031
3032    model E
3033        replaceable parameter A d;
3034        Real x;
3035    equation
3036        x = d.a;
3037    end E;
3038
3039        model F
3040        E e(redeclare parameter C d(a = 6));
3041    end F;
3042       
3043        F f;
3044end RedeclareTest34;
3045
3046
3047model RedeclareTest35
3048        model A
3049                replaceable package E = F;
3050        end A;
3051       
3052        model B
3053                extends A;
3054        replaceable C x constrainedby C(redeclare package D = E);
3055        end B;
3056       
3057        model C
3058                replaceable package D = G;
3059                Real z = D.c;
3060        end C;
3061   
3062    package F
3063        constant Real c = 1;
3064    end F;
3065   
3066    package G
3067        constant Real c = 0;
3068    end G;
3069       
3070        B w;
3071
3072        annotation(__JModelica(UnitTesting(tests={
3073                FlatteningTestCase(
3074                        name="RedeclareTest35",
3075                        description="Redeclare class in constrainedby",
3076                        flatModel="
3077fclass RedeclareTests.General.RedeclareTest35
3078 Real w.x.z = 1.0;
3079end RedeclareTests.General.RedeclareTest35;
3080")})));
3081end RedeclareTest35;
3082
3083
3084model RedeclareTest36
3085    model A
3086        extends B(redeclare G.D c(x = 1));
3087    end A;
3088   
3089    model B
3090        replaceable C c;
3091    end B;
3092   
3093    model C
3094    end C;
3095   
3096    package G
3097        model D
3098            parameter F x = 1;
3099            E e(y = x);
3100        end D;
3101       
3102        model E
3103            parameter F y;
3104        end E;
3105       
3106        type F = Real;
3107    end G;
3108   
3109    A a;
3110
3111        annotation(__JModelica(UnitTesting(tests={
3112                FlatteningTestCase(
3113                        name="RedeclareTest36",
3114                        description="Class lookup from replacing component",
3115                        flatModel="
3116fclass RedeclareTests.General.RedeclareTest36
3117 parameter Real a.c.x = 1 /* 1 */;
3118 parameter Real a.c.e.y = a.c.x;
3119end RedeclareTests.General.RedeclareTest36;
3120")})));
3121end RedeclareTest36;
3122
3123
3124model RedeclareTest37
3125    record A
3126        extends B(redeclare G.D c(x = 1));
3127    end A;
3128   
3129    record B
3130        replaceable C c;
3131    end B;
3132   
3133    record C
3134    end C;
3135   
3136    package G
3137        record D
3138            parameter F x = 1;
3139            E e(y = x);
3140        end D;
3141       
3142        record E
3143            parameter F y;
3144        end E;
3145       
3146        type F = Real;
3147    end G;
3148   
3149    A a;
3150
3151        annotation(__JModelica(UnitTesting(tests={
3152                FlatteningTestCase(
3153                        name="RedeclareTest37",
3154                        description="Class lookup from replacing record",
3155                        flatModel="
3156fclass RedeclareTests.General.RedeclareTest37
3157 parameter RedeclareTests.General.RedeclareTest37.A a(c(x = 1,e(y = a.c.x)));
3158
3159public
3160 record RedeclareTests.General.RedeclareTest37.G.E
3161  parameter Real y;
3162 end RedeclareTests.General.RedeclareTest37.G.E;
3163
3164 record RedeclareTests.General.RedeclareTest37.G.D
3165  parameter Real x;
3166  parameter RedeclareTests.General.RedeclareTest37.G.E e;
3167 end RedeclareTests.General.RedeclareTest37.G.D;
3168
3169 record RedeclareTests.General.RedeclareTest37.A
3170  parameter RedeclareTests.General.RedeclareTest37.G.D c;
3171 end RedeclareTests.General.RedeclareTest37.A;
3172
3173end RedeclareTests.General.RedeclareTest37;
3174")})));
3175end RedeclareTest37;
3176
3177
3178model RedeclareTest38
3179    model A
3180        replaceable B b constrainedby B;
3181    end A;
3182   
3183    model B
3184        C c[1];
3185    end B;
3186   
3187    model C
3188        Real x;
3189    end C;
3190   
3191    A a;
3192
3193        annotation(__JModelica(UnitTesting(tests={
3194                FlatteningTestCase(
3195                        name="RedeclareTest38",
3196                        description="Constrainedby with model containing array of models",
3197                        flatModel="
3198fclass RedeclareTests.General.RedeclareTest38
3199 Real a.b.c[1].x;
3200end RedeclareTests.General.RedeclareTest38;
3201")})));
3202end RedeclareTest38;
3203
3204
3205model RedeclareTest39
3206    function f1
3207        input Real x;
3208        output Real y;
3209    end f1;
3210   
3211    function f2
3212        extends f1;
3213    algorithm
3214        y := x + 1;
3215    end f2;
3216   
3217    model A
3218        replaceable function f = f1;
3219        Real x;
3220    equation
3221        x = f(time);
3222    end A;
3223   
3224    model B
3225        replaceable A a constrainedby A(redeclare function f = f2);
3226    end B;
3227   
3228    model C
3229        B b(redeclare A a);
3230    end C;
3231   
3232    C c;
3233
3234        annotation(__JModelica(UnitTesting(tests={
3235                FlatteningTestCase(
3236                        name="RedeclareTest39",
3237                        description="Error check of redeclare that needs the modifications from the constrainedby clause to be valid",
3238                        flatModel="
3239fclass RedeclareTests.General.RedeclareTest39
3240 Real c.b.a.x;
3241equation
3242 c.b.a.x = RedeclareTests.General.RedeclareTest39.f2(time);
3243
3244public
3245 function RedeclareTests.General.RedeclareTest39.f2
3246  input Real x;
3247  output Real y;
3248 algorithm
3249  y := x + 1;
3250  return;
3251 end RedeclareTests.General.RedeclareTest39.f2;
3252
3253end RedeclareTests.General.RedeclareTest39;
3254")})));
3255end RedeclareTest39;
3256
3257
3258model RedeclareTest40
3259    function f1
3260        input Real x;
3261        output Real y;
3262    end f1;
3263   
3264    function f2
3265        extends f1;
3266    algorithm
3267        y := x + 1;
3268    end f2;
3269   
3270    model A
3271        replaceable function f = f1;
3272        Real x = f(time);
3273    end A;
3274   
3275    model B
3276        replaceable A a constrainedby A(redeclare function f = f2);
3277    end B;
3278   
3279    model C
3280        B b(redeclare A a);
3281    end C;
3282   
3283    C c;
3284
3285    annotation(__JModelica(UnitTesting(tests={
3286        FlatteningTestCase(
3287            name="RedeclareTest40",
3288            description="Check that only final redeclared are error checked",
3289            flatModel="
3290fclass RedeclareTests.General.RedeclareTest40
3291 Real c.b.a.x = RedeclareTests.General.RedeclareTest40.f2(time);
3292
3293public
3294 function RedeclareTests.General.RedeclareTest40.f2
3295  input Real x;
3296  output Real y;
3297 algorithm
3298  y := x + 1;
3299  return;
3300 end RedeclareTests.General.RedeclareTest40.f2;
3301
3302end RedeclareTests.General.RedeclareTest40;
3303")})));
3304end RedeclareTest40;
3305
3306
3307model RedeclareTest41
3308    package A
3309        replaceable model B
3310            Real x = 1;
3311        end B;
3312    end A;
3313   
3314    package C
3315        extends A;
3316        redeclare model extends B
3317            Real y = 2;
3318        end B;
3319    end C;
3320   
3321    model D
3322        extends C.B;
3323    end D;
3324   
3325    D b;
3326
3327    annotation(__JModelica(UnitTesting(tests={
3328        FlatteningTestCase(
3329            name="RedeclareTest41",
3330            description="",
3331            flatModel="
3332fclass RedeclareTests.General.RedeclareTest41
3333 Real b.y = 2;
3334 Real b.x = 1;
3335end RedeclareTests.General.RedeclareTest41;
3336")})));
3337end RedeclareTest41;
3338
3339
3340model RedeclareTest42
3341    model A
3342        parameter Integer n = 2;
3343        D d[n](x = {1,2,3});
3344    end A;
3345   
3346    model B = A(n = 3);
3347   
3348    model C
3349        replaceable A a constrainedby A;
3350    end C;
3351   
3352    model D
3353        Real x;
3354    end D;
3355   
3356    C c(redeclare B a);
3357
3358    annotation(__JModelica(UnitTesting(tests={
3359        FlatteningTestCase(
3360            name="RedeclareTest42",
3361            description="Redeclare that changes size of array of models",
3362            flatModel="
3363fclass RedeclareTests.General.RedeclareTest42
3364 structural parameter Integer c.a.n = 3 /* 3 */;
3365 Real c.a.d[1].x = 1;
3366 Real c.a.d[2].x = 2;
3367 Real c.a.d[3].x = 3;
3368end RedeclareTests.General.RedeclareTest42;
3369")})));
3370end RedeclareTest42;
3371
3372
3373model RedeclareTest43
3374    package A
3375        replaceable model B
3376        end B;
3377    end A;
3378   
3379    package C
3380        package D
3381            extends A;
3382            redeclare model extends B
3383                Real x = E.a;
3384            end B;
3385        end D;
3386       
3387        package E
3388            constant Real a = 1;
3389        end E;
3390    end C;
3391   
3392    package F
3393        extends C.D;
3394    end F;
3395   
3396    F.B b;
3397
3398    annotation(__JModelica(UnitTesting(tests={
3399        FlatteningTestCase(
3400            name="RedeclareTest43",
3401            description="Class lookup from inside redeclare class extends referring to class in surrounding package",
3402            flatModel="
3403fclass RedeclareTests.General.RedeclareTest43
3404 Real b.x = 1.0;
3405end RedeclareTests.General.RedeclareTest43;
3406")})));
3407end RedeclareTest43;
3408
3409
3410model RedeclareTest44
3411    package A
3412        replaceable model B
3413              Real x;
3414          equation
3415              x = time;
3416        end B;
3417    end A;
3418   
3419    package C
3420        extends A;
3421       
3422        redeclare replaceable model extends B
3423              Real y;
3424          equation
3425              y = time;
3426        end B;
3427    end C;
3428   
3429    package D = C;
3430   
3431    package E
3432        extends D;
3433       
3434        redeclare model extends B
3435              Real z;
3436          equation
3437              z = time;
3438        end B;
3439    end E;
3440   
3441    E.B b;
3442
3443    annotation(__JModelica(UnitTesting(tests={
3444        FlatteningTestCase(
3445            name="RedeclareTest44",
3446            description="Redeclares before and after short class decl",
3447            flatModel="
3448fclass RedeclareTests.General.RedeclareTest44
3449 Real b.z;
3450 Real b.y;
3451 Real b.x;
3452equation
3453 b.z = time;
3454 b.y = time;
3455 b.x = time;
3456end RedeclareTests.General.RedeclareTest44;
3457")})));
3458end RedeclareTest44;
3459
3460
3461model RedeclareTest45
3462    package A
3463    end A;
3464   
3465    package B
3466        model C
3467            Real x = time;
3468        end C;
3469    end B;
3470   
3471    replaceable package D = B constrainedby A;
3472   
3473    D.C c;
3474    Real y = c.x;
3475
3476    annotation(__JModelica(UnitTesting(tests={
3477        WarningTestCase(
3478            name="RedeclareTest45",
3479            description="",
3480            errorMessage="
34811 warnings found:
3482
3483Warning at line 13, column 7, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE:
3484  Access to class C not recommended, it is not present in constraining type of declaration 'replaceable package D = B constrainedby A'
3485")})));
3486end RedeclareTest45;
3487
3488
3489model RedeclareTest46
3490    model A
3491        Real x = time;
3492    end A;
3493   
3494    model B
3495        extends A;
3496        Real y = 2 * time;
3497    end B;
3498   
3499    model C
3500        extends A;
3501        Real z = 3 * time;
3502    end C;
3503   
3504    model D
3505        extends A;
3506        Real w = 4 * time;
3507    end D;
3508   
3509    model E
3510        replaceable B b constrainedby A;
3511    end E;
3512   
3513    model F
3514        extends E(redeclare C b);
3515    end F;
3516   
3517    model G
3518        extends E(redeclare D b);
3519    end G;
3520   
3521    model H
3522        replaceable F f constrainedby E;
3523    end H;
3524   
3525    model I
3526        extends H(redeclare G f);
3527    end I;
3528   
3529    I i;
3530
3531    annotation(__JModelica(UnitTesting(tests={
3532        FlatteningTestCase(
3533            name="RedeclareTest46",
3534            description="When checking constraining type, use constraining type for replaceable components/classes within the constraining type",
3535            flatModel="
3536fclass RedeclareTests.General.RedeclareTest46
3537 Real i.f.b.w = 4 * time;
3538 Real i.f.b.x = time;
3539end RedeclareTests.General.RedeclareTest46;
3540")})));
3541end RedeclareTest46;
3542
3543
3544model RedeclareTest47
3545    model A
3546        Real x = time;
3547    end A;
3548   
3549    model B
3550        extends A;
3551        Real y = 2 * time;
3552    end B;
3553   
3554    model C
3555        extends B;
3556        Real z = 3 * time;
3557    end C;
3558   
3559    model D
3560        replaceable B b constrainedby A;
3561    end D;
3562   
3563    model E
3564        extends D(redeclare C b);
3565    end E;
3566   
3567    model F
3568        replaceable E e constrainedby D;
3569        Real w = e.b.y;
3570    end F;
3571   
3572    F f;
3573
3574    annotation(__JModelica(UnitTesting(tests={
3575        WarningTestCase(
3576            name="RedeclareTest47",
3577            description="When checking constraining type, use constraining type for replaceable components/classes within the constraining type",
3578            errorMessage="
35791 warnings found:
3580
3581Warning at line 26, column 22, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE,
3582In component f:
3583  Access to component y not recommended, it is not present in constraining type of declaration 'replaceable B b constrainedby A'
3584")})));
3585end RedeclareTest47;
3586
3587
3588model RedeclareTest48
3589    package A
3590    end A;
3591   
3592    package B
3593        extends A;
3594        type I = Real;
3595    end B;
3596   
3597    package C
3598        extends B;
3599        type J = Real;
3600    end C;
3601   
3602    package D
3603        replaceable package E = B constrainedby A;
3604    end D;
3605   
3606    package F
3607        extends D(redeclare package E = C);
3608    end F;
3609   
3610    package G
3611        replaceable package H = F constrainedby D;
3612    end G;
3613   
3614    G.H.E.I x = time;
3615
3616    annotation(__JModelica(UnitTesting(tests={
3617        WarningTestCase(
3618            name="RedeclareTest48",
3619            description="When checking constraining type, use constraining type for replaceable components/classes within the constraining type",
3620            errorMessage="
36211 warnings found:
3622
3623Warning at line 27, column 11, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE:
3624  Access to class I not recommended, it is not present in constraining type of declaration 'replaceable package E = B constrainedby A'
3625")})));
3626end RedeclareTest48;
3627
3628
3629model RedeclareTest49
3630    model A
3631        Real x = time;
3632    end A;
3633   
3634    model B
3635        extends A;
3636        Real y = 2 * time;
3637    end B;
3638   
3639    model C
3640        A a;
3641    end C;
3642   
3643    model D
3644        B a;
3645    end D;
3646   
3647    model E
3648        replaceable D c constrainedby C;
3649        Real z = c.a.y;
3650    end E;
3651   
3652    E e;
3653
3654    annotation(__JModelica(UnitTesting(tests={
3655        WarningTestCase(
3656            name="RedeclareTest49",
3657            description="Check for usage of components not in constraining type also when accessing nestled components",
3658            errorMessage="
36591 warnings found:
3660
3661Warning at line 21, column 22, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE,
3662In component e:
3663  Access to component y not recommended, it is not present in constraining type of declaration 'replaceable D c constrainedby C'
3664")})));
3665end RedeclareTest49;
3666
3667
3668model RedeclareTest50
3669    function f1
3670        input Real a;
3671        input Real b;
3672        output Real c = a + b;
3673    algorithm
3674    end f1;
3675   
3676    model A
3677        replaceable function f2 = f1(b=2);
3678   
3679        Real x = f2(time);
3680    end A;
3681
3682    model B = A(redeclare function f2 = f1);
3683   
3684    B b;
3685
3686    annotation(__JModelica(UnitTesting(tests={
3687        FlatteningTestCase(
3688            name="RedeclareTest50",
3689            description="Check that modifications on constraining type of functions are retained",
3690            flatModel="
3691fclass RedeclareTests.General.RedeclareTest50
3692 Real b.x = RedeclareTests.General.RedeclareTest50.b.f2(time, 2);
3693
3694public
3695 function RedeclareTests.General.RedeclareTest50.b.f2
3696  input Real a;
3697  input Real b;
3698  output Real c;
3699 algorithm
3700  c := a + b;
3701  return;
3702 end RedeclareTests.General.RedeclareTest50.b.f2;
3703
3704end RedeclareTests.General.RedeclareTest50;
3705")})));
3706end RedeclareTest50;
3707
3708
3709model RedeclareTest51
3710    record A
3711        String b;
3712    end A;
3713
3714    parameter A[:] a;
3715    parameter String[:] c = a.b;
3716
3717    annotation(__JModelica(UnitTesting(tests={
3718        WarningTestCase(
3719            name="RedeclareTest51",
3720            description="Check that arrays of unknown size are correctly error checked",
3721            checkType=check,
3722            errorMessage="
37233 warnings found:
3724
3725Warning at line 3, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', PARAMETER_MISSING_BINDING_EXPRESSION,
3726In component a:
3727  The parameter a.b does not have a binding expression
3728")})));
3729end RedeclareTest51;
3730
3731
3732model RedeclareTest52
3733    model R
3734        Real x = time;
3735    end R;
3736
3737    model M
3738        parameter Integer n;
3739        R[:] r;
3740    end M;
3741
3742    parameter Integer k = 0;
3743    M m[k](redeclare R r, n = 1:k);
3744
3745    annotation(__JModelica(UnitTesting(tests={
3746        FlatteningTestCase(
3747            name="RedeclareTest52",
3748            description="Check that arrays of unknown size are correctly error checked",
3749            flatModel="
3750fclass RedeclareTests.General.RedeclareTest52
3751 structural parameter Integer k = 0 /* 0 */;
3752end RedeclareTests.General.RedeclareTest52;
3753")})));
3754end RedeclareTest52;
3755
3756
3757model RedeclareTest53
3758    model A
3759        Real x[2];
3760    end A;
3761       
3762        model B
3763                Real x;
3764        end B;
3765
3766    model C
3767        replaceable A a;
3768    end C;
3769
3770    C c(redeclare B a);
3771
3772    annotation(__JModelica(UnitTesting(tests={
3773        ErrorTestCase(
3774            name="RedeclareTest53",
3775            description="Error for redeclare that replace a class containing an array with class containing a scalar with the same name",
3776            errorMessage="
37771 errors found:
3778
3779Error at line 14, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', REPLACING_CLASS_NOT_SUBTYPE_OF_CONSTRAINING_CLASS:
3780  In the declaration 'redeclare B a', the replacing class is not a subtype of the constraining class from the declaration 'replaceable A a',
3781    because their instances of x have incompatible number of dimensions
3782")})));
3783end RedeclareTest53;
3784
3785
3786model RedeclareTest54
3787    model A
3788        Real x;
3789    end A;
3790   
3791    model B
3792        extends A;
3793        Real y;
3794    end B;
3795   
3796    model C
3797        extends A;
3798        Real z;
3799    end C;
3800   
3801    model D
3802        extends A;
3803        Real w;
3804    end D;
3805   
3806    model E
3807        replaceable model F = B constrainedby A;
3808        F f;
3809    end E;
3810   
3811    model G
3812        extends E(redeclare model F = C);
3813    end G;
3814   
3815    model H
3816        extends E(redeclare model F = D);
3817    end H;
3818   
3819    model I
3820        replaceable G g constrainedby E;
3821    end I;
3822   
3823    model J
3824        extends I(redeclare H g);
3825    end J;
3826   
3827    I i;
3828
3829    annotation(__JModelica(UnitTesting(tests={
3830        FlatteningTestCase(
3831            name="RedeclareTest54",
3832            description="Redeclare with constraining type that contains a component of a replaceable class.",
3833            flatModel="
3834fclass RedeclareTests.General.RedeclareTest54
3835 Real i.g.f.z;
3836 Real i.g.f.x;
3837end RedeclareTests.General.RedeclareTest54;
3838")})));
3839end RedeclareTest54;
3840
3841model RedeclareTest55
3842    model R1
3843        Real x;
3844    end R1;
3845   
3846    replaceable R1[2] r1 constrainedby R1(each x = time);
3847
3848    annotation(__JModelica(UnitTesting(tests={
3849   
3850        FlatteningTestCase(
3851            name="RedeclareTest55",
3852            description="Redeclare with each in constraining type",
3853            flatModel="
3854fclass RedeclareTests.General.RedeclareTest55
3855 Real r1[1].x = time;
3856 Real r1[2].x = time;
3857end RedeclareTests.General.RedeclareTest55;
3858")})));
3859end RedeclareTest55;
3860
3861model RedeclareTest56_err
3862    model R1
3863        Real x;
3864    end R1;
3865
3866    replaceable R1 r2 constrainedby R1(each x = time);
3867
3868    annotation(__JModelica(UnitTesting(tests={
3869        WarningTestCase(
3870            name="RedeclareTest56_err",
3871            description="Redeclare with each in constraining type",
3872            errorMessage="
38731 warnings found:
3874
3875Warning at line 6, column 40, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', EACH_APPLIED_ON_SCALAR:
3876  The 'each' keyword should not be applied to a modification of a scalar component: each x = time
3877")})));
3878end RedeclareTest56_err;
3879
3880
3881model RedeclareTest57
3882    model A
3883        parameter Integer n = 1;
3884        parameter Real x[n];
3885    end A;
3886   
3887    model B
3888        replaceable A a(n = 2);
3889    end B;
3890   
3891    model C
3892        extends B(redeclare A a(x = 1:2));
3893    end C;
3894   
3895    C c;
3896
3897    annotation(__JModelica(UnitTesting(tests={
3898        FlatteningTestCase(
3899            name="RedeclareTest57",
3900            description="Test that modifications from constraining class are considered when error checking redeclares",
3901            flatModel="
3902fclass RedeclareTests.General.RedeclareTest57
3903 structural parameter Integer c.a.n = 2 /* 2 */;
3904 parameter Real c.a.x[2] = 1:2 /* { 1, 2 } */;
3905end RedeclareTests.General.RedeclareTest57;
3906")})));
3907end RedeclareTest57;
3908
3909
3910model RedeclareTest58
3911    model A
3912        parameter Integer n = 1;
3913        parameter Real x[n];
3914    end A;
3915   
3916    model B
3917        replaceable model D = A(n = 2);
3918        D d;
3919    end B;
3920   
3921    model C
3922        extends B(redeclare model D = A(x = 1:2));
3923    end C;
3924   
3925    C c;
3926
3927    annotation(__JModelica(UnitTesting(tests={
3928        FlatteningTestCase(
3929            name="RedeclareTest58",
3930            description="Test that modifications from constraining class are considered when error checking redeclares",
3931            flatModel="
3932fclass RedeclareTests.General.RedeclareTest58
3933 structural parameter Integer c.d.n = 2 /* 2 */;
3934 parameter Real c.d.x[2] = 1:2 /* { 1, 2 } */;
3935end RedeclareTests.General.RedeclareTest58;
3936")})));
3937end RedeclareTest58;
3938
3939
3940model RedeclareTest59
3941    model A
3942        parameter Integer n = 1;
3943        parameter Real x[n];
3944    end A;
3945   
3946    model B
3947        replaceable A a constrainedby A(n = 2);
3948    end B;
3949   
3950    model C
3951        extends B(redeclare A a(x = 1:2));
3952    end C;
3953   
3954    C c;
3955
3956    annotation(__JModelica(UnitTesting(tests={
3957        FlatteningTestCase(
3958            name="RedeclareTest59",
3959            description="Test that modifications from constraining class are considered when error checking redeclares",
3960            flatModel="
3961fclass RedeclareTests.General.RedeclareTest59
3962 structural parameter Integer c.a.n = 2 /* 2 */;
3963 parameter Real c.a.x[2] = 1:2 /* { 1, 2 } */;
3964end RedeclareTests.General.RedeclareTest59;
3965")})));
3966end RedeclareTest59;
3967
3968
3969model RedeclareTest60
3970    model A
3971        parameter Integer n = 1;
3972        parameter Real x[n];
3973    end A;
3974   
3975    model B
3976        replaceable model D = A constrainedby A(n = 2);
3977        D d;
3978    end B;
3979   
3980    model C
3981        extends B(redeclare model D = A(x = 1:2));
3982    end C;
3983   
3984    C c;
3985
3986    annotation(__JModelica(UnitTesting(tests={
3987        FlatteningTestCase(
3988            name="RedeclareTest60",
3989            description="Test that modifications from constraining class are considered when error checking redeclares",
3990            flatModel="
3991fclass RedeclareTests.General.RedeclareTest60
3992 structural parameter Integer c.d.n = 2 /* 2 */;
3993 parameter Real c.d.x[2] = 1:2 /* { 1, 2 } */;
3994end RedeclareTests.General.RedeclareTest60;
3995")})));
3996end RedeclareTest60;
3997
3998
3999model RedeclareTest61
4000    model A
4001        parameter Real x[:] = {1};
4002    end A;
4003   
4004    model B
4005        replaceable A a constrainedby A(x = 1:2);
4006    end B;
4007   
4008    model C
4009        extends B(redeclare A a);
4010    end C;
4011   
4012    C c;
4013
4014    annotation(__JModelica(UnitTesting(tests={
4015        FlatteningTestCase(
4016            name="RedeclareTest61",
4017            description="Test that modifications from constraining class are considered when error checking redeclares",
4018            flatModel="
4019fclass RedeclareTests.General.RedeclareTest61
4020 parameter Real c.a.x[2] = 1:2 /* { 1, 2 } */;
4021end RedeclareTests.General.RedeclareTest61;
4022")})));
4023end RedeclareTest61;
4024
4025
4026model RedeclareTest62
4027    model A
4028        parameter Real x[:] = {1};
4029    end A;
4030   
4031    model B
4032        replaceable model D = A constrainedby A(x = 1:2);
4033        D d;
4034    end B;
4035   
4036    model C
4037        extends B(redeclare model D = A);
4038    end C;
4039   
4040    C c;
4041
4042    annotation(__JModelica(UnitTesting(tests={
4043        FlatteningTestCase(
4044            name="RedeclareTest62",
4045            description="Test that modifications from constraining class are considered when error checking redeclares",
4046            flatModel="
4047fclass RedeclareTests.General.RedeclareTest62
4048 parameter Real c.d.x[2] = 1:2 /* { 1, 2 } */;
4049end RedeclareTests.General.RedeclareTest62;
4050")})));
4051end RedeclareTest62;
4052
4053
4054model RedeclareTest63
4055    model A
4056        Real x;
4057    end A;
4058   
4059    model B
4060        extends A;
4061        Real y;
4062    end B;
4063   
4064    model C
4065        extends A;
4066        Real z;
4067    end C;
4068   
4069    model D
4070        extends A;
4071        Real w;
4072    end D;
4073   
4074    model E
4075        replaceable model F = B constrainedby A;
4076        model G = F;
4077        G g;
4078    end E;
4079   
4080    model H
4081        extends E(redeclare model F = C);
4082    end H;
4083   
4084    model I
4085        extends E(redeclare model F = D);
4086    end I;
4087   
4088    model J
4089        replaceable H h constrainedby E;
4090    end J;
4091   
4092    model K
4093        extends J(redeclare I h);
4094    end K;
4095   
4096    J j;
4097
4098    annotation(__JModelica(UnitTesting(tests={
4099        FlatteningTestCase(
4100            name="RedeclareTest63",
4101            description="Redeclare with constraining type that contains a component of a short class decl that points to a replaceable class",
4102            flatModel="
4103fclass RedeclareTests.General.RedeclareTest63
4104 Real j.h.g.z;
4105 Real j.h.g.x;
4106end RedeclareTests.General.RedeclareTest63;
4107")})));
4108end RedeclareTest63;
4109
4110
4111model RedeclareTest64
4112    model A
4113        Real x;
4114    end A;
4115   
4116    model B
4117        extends A;
4118        Real y;
4119    end B;
4120   
4121    model C
4122        extends A;
4123        Real z;
4124    end C;
4125   
4126    model D
4127        extends A;
4128        Real w;
4129    end D;
4130   
4131    model E
4132        replaceable model F = B constrainedby A;
4133        F f[2];
4134    end E;
4135   
4136    model G
4137        extends E(redeclare model F = C);
4138    end G;
4139   
4140    model H
4141        extends E(redeclare model F = D);
4142    end H;
4143   
4144    model I
4145        replaceable G g constrainedby E;
4146    end I;
4147   
4148    model J
4149        extends I(redeclare H g);
4150    end J;
4151   
4152    I i;
4153
4154    annotation(__JModelica(UnitTesting(tests={
4155        FlatteningTestCase(
4156            name="RedeclareTest64",
4157            description="Redeclare with constraining type that contains an array component of a replaceable class.",
4158            flatModel="
4159fclass RedeclareTests.General.RedeclareTest64
4160 Real i.g.f[1].z;
4161 Real i.g.f[1].x;
4162 Real i.g.f[2].z;
4163 Real i.g.f[2].x;
4164end RedeclareTests.General.RedeclareTest64;
4165")})));
4166end RedeclareTest64;
4167
4168
4169model RedeclareTest65
4170    model A
4171        Real x = 1;
4172    end A;
4173   
4174    replaceable model B = A constrainedby A(x = 2);
4175   
4176    B b;
4177
4178    annotation(__JModelica(UnitTesting(tests={
4179        FlatteningTestCase(
4180            name="RedeclareTest65",
4181            description="Modifications on constraining type of class for component",
4182            flatModel="
4183fclass RedeclareTests.General.RedeclareTest65
4184 Real b.x = 2;
4185end RedeclareTests.General.RedeclareTest65;
4186")})));
4187end RedeclareTest65;
4188
4189
4190model RedeclareTest66
4191    model A
4192        Real x = 1;
4193    end A;
4194   
4195    replaceable model B = A constrainedby A(x = 2);
4196   
4197    model C = B;
4198   
4199    C c;
4200
4201    annotation(__JModelica(UnitTesting(tests={
4202        FlatteningTestCase(
4203            name="RedeclareTest66",
4204            description="Modifications on constraining type of class for short class decl",
4205            flatModel="
4206fclass RedeclareTests.General.RedeclareTest66
4207 Real c.x = 2;
4208end RedeclareTests.General.RedeclareTest66;
4209")})));
4210end RedeclareTest66;
4211
4212
4213model RedeclareTest67
4214    model A
4215        Real x = 1;
4216    end A;
4217   
4218    replaceable model B = A constrainedby A(x = 2);
4219   
4220    model C
4221        extends B;
4222    end C;
4223   
4224    C c;
4225
4226    annotation(__JModelica(UnitTesting(tests={
4227        FlatteningTestCase(
4228            name="RedeclareTest67",
4229            description="Modifications on constraining type of class for extends",
4230            flatModel="
4231fclass RedeclareTests.General.RedeclareTest67
4232 Real c.x = 2;
4233end RedeclareTests.General.RedeclareTest67;
4234")})));
4235end RedeclareTest67;
4236
4237
4238model RedeclareTest68
4239    model A
4240        parameter Real x = 1;
4241    end A;
4242   
4243    model B
4244        extends A(x = 2);
4245    end B;
4246   
4247    model C
4248        replaceable model D = A;
4249        D d;
4250    end C;
4251   
4252    model E
4253        extends C(redeclare model D = F);
4254    end E;
4255   
4256    replaceable model F = B constrainedby A(x = 3);
4257   
4258    E e;
4259
4260    annotation(__JModelica(UnitTesting(tests={
4261        FlatteningTestCase(
4262            name="RedeclareTest68",
4263            description="Modifications on constraining type of class for component with two levels of redeclares",
4264            flatModel="
4265fclass RedeclareTests.General.RedeclareTest68
4266 parameter Real e.d.x = 3 /* 3 */;
4267end RedeclareTests.General.RedeclareTest68;
4268")})));
4269end RedeclareTest68;
4270
4271
4272model RedeclareTest69
4273    model A
4274        replaceable package C = D constrainedby E;
4275        C.F f;
4276    end A;
4277   
4278    model B
4279        extends A(redeclare package C = E);
4280    end B;
4281   
4282    package D
4283        model F
4284            Real x = 1;
4285            Real y = 2;
4286        end F;
4287    end D;
4288   
4289    package E
4290        model F
4291            Real x = 3;
4292        end F;
4293    end E;
4294   
4295    replaceable B b constrainedby A;
4296
4297    annotation(__JModelica(UnitTesting(tests={
4298        FlatteningTestCase(
4299            name="RedeclareTest69",
4300            description="Replaceable package in constraining type",
4301            flatModel="
4302fclass RedeclareTests.General.RedeclareTest69
4303 Real b.f.x = 3;
4304end RedeclareTests.General.RedeclareTest69;
4305")})));
4306end RedeclareTest69;
4307
4308model RedeclareTest70
4309    model A
4310        Real[:,2] x = {{1,2}};
4311    end A;
4312   
4313    model B
4314        replaceable model A2 = A;
4315        A2[2] a;
4316    end B;
4317   
4318    model C
4319        replaceable model A3 = A;
4320        B b1(redeclare model A2 = A(x={{3,4}}));
4321        B b2(redeclare model A2 = A);
4322        B b3(redeclare model A2 = A3);
4323    end C;
4324   
4325    C c(redeclare model A3 = A(x={{5,6}}));
4326
4327    annotation(__JModelica(UnitTesting(tests={
4328        FlatteningTestCase(
4329            name="RedeclareTest70",
4330            description="Replaceable array class binding expression",
4331            flatModel="
4332fclass RedeclareTests.General.RedeclareTest70
4333 Real c.b1.a[1].x[1,2] = {{3, 4}};
4334 Real c.b1.a[2].x[1,2] = {{3, 4}};
4335 Real c.b2.a[1].x[1,2] = {{1, 2}};
4336 Real c.b2.a[2].x[1,2] = {{1, 2}};
4337 Real c.b3.a[1].x[1,2] = {{5, 6}};
4338 Real c.b3.a[2].x[1,2] = {{5, 6}};
4339end RedeclareTests.General.RedeclareTest70;
4340")})));
4341end RedeclareTest70;
4342
4343model RedeclareTest71
4344    model A
4345        Real[:,2] x = {{1,2}};
4346    end A;
4347   
4348    model B
4349        replaceable model A2 = A;
4350        A2[2] a;
4351    end B;
4352   
4353    model C
4354        replaceable model A3 = A;
4355        B b1(redeclare model A2 = A[2](x={{{3,4}},{{5,6}}}));
4356        B b3(redeclare model A2 = A3);
4357    end C;
4358   
4359    C c(redeclare model A3 = A[2](x={{{7,8}},{{9,0}}}));
4360
4361    annotation(__JModelica(UnitTesting(tests={
4362        FlatteningTestCase(
4363            name="RedeclareTest71",
4364            description="Replaceable array class binding expression",
4365            flatModel="
4366fclass RedeclareTests.General.RedeclareTest71
4367 Real c.b1.a[1,1].x[1,2] = {{3, 4}};
4368 Real c.b1.a[1,2].x[1,2] = {{5, 6}};
4369 Real c.b1.a[2,1].x[1,2] = {{3, 4}};
4370 Real c.b1.a[2,2].x[1,2] = {{5, 6}};
4371 Real c.b3.a[1,1].x[1,2] = {{7, 8}};
4372 Real c.b3.a[1,2].x[1,2] = {{9, 0}};
4373 Real c.b3.a[2,1].x[1,2] = {{7, 8}};
4374 Real c.b3.a[2,2].x[1,2] = {{9, 0}};
4375end RedeclareTests.General.RedeclareTest71;
4376")})));
4377end RedeclareTest71;
4378
4379
4380model RedeclareTest72
4381    model A
4382        replaceable B b constrainedby C;
4383    end A;
4384   
4385    model B
4386        Real x;
4387    end B;
4388   
4389    model C
4390    end C;
4391   
4392    model D
4393        extends A(replaceable E b constrainedby F);
4394        Real y2 = b.y;  // OK
4395    end D;
4396   
4397    model E
4398        Real x;
4399        Real y;
4400    end E;
4401   
4402    model F
4403        Real y;
4404    end F;
4405   
4406    model G
4407        extends D(replaceable H b constrainedby I);
4408        Real x2 = b.x;  // error - not in I
4409        Real z2 = b.z;  // OK
4410    end G;
4411   
4412    model H
4413        Real x;
4414        Real y;
4415        Real z;
4416    end H;
4417   
4418    model I
4419        Real y;
4420        Real z;
4421    end I;
4422   
4423    G g;
4424
4425    annotation(__JModelica(UnitTesting(tests={
4426        WarningTestCase(
4427            name="RedeclareTest72",
4428            description="Redeclare chain with changed constraining type in middle",
4429            errorMessage="
44301 warnings found:
4431
4432Warning at line 29, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE,
4433In component g:
4434  Access to component x not recommended, it is not present in constraining type of declaration 'replaceable H b constrainedby I'
4435")})));
4436end RedeclareTest72;
4437
4438
4439model RedeclareTest73
4440    model A
4441        replaceable B b constrainedby C;
4442    end A;
4443   
4444    model B
4445        Real x;
4446    end B;
4447   
4448    model C
4449    end C;
4450   
4451    model D
4452        extends A(replaceable E b constrainedby F);
4453        Real y2 = b.y;  // OK
4454    end D;
4455   
4456    model E
4457        Real x;
4458        Real y;
4459    end E;
4460   
4461    model F
4462        Real y;
4463    end F;
4464   
4465    model G
4466        extends D(replaceable H b);
4467        Real x2 = b.x;  // error - not in F
4468        Real z2 = b.z;  // error - not in F
4469    end G;
4470   
4471    model H
4472        Real x;
4473        Real y;
4474        Real z;
4475    end H;
4476   
4477    G g;
4478
4479    annotation(__JModelica(UnitTesting(tests={
4480        WarningTestCase(
4481            name="RedeclareTest73",
4482            description="Redeclare chain with changed constraining type in middle",
4483            errorMessage="
44842 warnings found:
4485
4486Warning at line 29, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE,
4487In component g:
4488  Access to component x not recommended, it is not present in constraining type of declaration 'replaceable E b constrainedby F'
4489
4490Warning at line 30, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE,
4491In component g:
4492  Access to component z not recommended, it is not present in constraining type of declaration 'replaceable E b constrainedby F'
4493")})));
4494end RedeclareTest73;
4495
4496
4497model RedeclareTest74
4498    model A
4499        replaceable model J = B constrainedby C;
4500    end A;
4501   
4502    model B
4503        constant Real x = 1;
4504    end B;
4505   
4506    model C
4507    end C;
4508   
4509    model D
4510        extends A(replaceable model J = E constrainedby F);
4511        Real y2 = J.y;  // OK
4512    end D;
4513   
4514    model E
4515        constant Real x = 2;
4516        constant Real y = 3;
4517    end E;
4518   
4519    model F
4520        constant Real y = 4;
4521    end F;
4522   
4523    model G
4524        extends D(replaceable model J = H constrainedby I);
4525        Real x2 = J.x;  // error - not in I
4526        Real z2 = J.z;  // OK
4527    end G;
4528   
4529    model H
4530        constant Real x = 5;
4531        constant Real y = 6;
4532        constant Real z = 7;
4533    end H;
4534   
4535    model I
4536        constant Real y = 8;
4537        constant Real z = 9;
4538    end I;
4539   
4540    G g;
4541
4542    annotation(__JModelica(UnitTesting(tests={
4543        WarningTestCase(
4544            name="RedeclareTest74",
4545            description="Redeclare chain with changed constraining type in middle",
4546            errorMessage="
45471 warnings found:
4548
4549Warning at line 29, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE,
4550In component g:
4551  Access to component x not recommended, it is not present in constraining type of declaration 'replaceable model J = H constrainedby I'
4552")})));
4553end RedeclareTest74;
4554
4555
4556model RedeclareTest75
4557    model A
4558        replaceable model J = B constrainedby C;
4559    end A;
4560   
4561    model B
4562        constant Real x = 1;
4563    end B;
4564   
4565    model C
4566    end C;
4567   
4568    model D
4569        extends A(replaceable model J = E constrainedby F);
4570        Real y2 = J.y;  // OK
4571    end D;
4572   
4573    model E
4574        constant Real x = 2;
4575        constant Real y = 3;
4576    end E;
4577   
4578    model F
4579        constant Real y = 4;
4580    end F;
4581   
4582    model G
4583        extends D(replaceable model J = H);
4584        Real x2 = J.x;  // error - not in F
4585        Real z2 = J.z;  // error - not in F
4586    end G;
4587   
4588    model H
4589        constant Real x = 5;
4590        constant Real y = 6;
4591        constant Real z = 7;
4592    end H;
4593   
4594    G g;
4595
4596    annotation(__JModelica(UnitTesting(tests={
4597        WarningTestCase(
4598            name="RedeclareTest75",
4599            description="Redeclare chain with changed constraining type in middle",
4600            errorMessage="
46012 warnings found:
4602
4603Warning at line 29, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE,
4604In component g:
4605  Access to component x not recommended, it is not present in constraining type of declaration 'replaceable model J = E constrainedby F'
4606
4607Warning at line 30, column 21, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', NOT_IN_CONSTRAINING_TYPE,
4608In component g:
4609  Access to component z not recommended, it is not present in constraining type of declaration 'replaceable model J = E constrainedby F'
4610")})));
4611end RedeclareTest75;
4612
4613
4614model RedeclareTest76
4615    record R2
4616        Real w;
4617    end R2;
4618   
4619    record R1
4620        R2 x = R2(time);
4621    end R1;
4622   
4623    record R
4624        extends R1;
4625    end R;
4626   
4627    model A
4628        R1 r;
4629        replaceable D x;
4630    end A;
4631   
4632    model B
4633        extends A(r = R());
4634        redeclare E x;
4635    end B;
4636   
4637    model D
4638        Real y = time+2;
4639    end D;
4640   
4641    model E
4642        extends D(y=time+3);
4643    end E;
4644   
4645    B b;
4646
4647    annotation(__JModelica(UnitTesting(tests={
4648        FlatteningTestCase(
4649            name="RedeclareTest76",
4650            description="Check that environment is correctly calculated for extends in record constructors (see #5044)",
4651            flatModel="
4652fclass RedeclareTests.General.RedeclareTest76
4653 RedeclareTests.General.RedeclareTest76.R1 b.r = RedeclareTests.General.RedeclareTest76.R(RedeclareTests.General.RedeclareTest76.R2(time));
4654 Real b.x.y = time + 3;
4655
4656public
4657 record RedeclareTests.General.RedeclareTest76.R2
4658  Real w;
4659 end RedeclareTests.General.RedeclareTest76.R2;
4660
4661 record RedeclareTests.General.RedeclareTest76.R1
4662  RedeclareTests.General.RedeclareTest76.R2 x;
4663 end RedeclareTests.General.RedeclareTest76.R1;
4664
4665 record RedeclareTests.General.RedeclareTest76.R
4666  RedeclareTests.General.RedeclareTest76.R2 x;
4667 end RedeclareTests.General.RedeclareTest76.R;
4668
4669end RedeclareTests.General.RedeclareTest76;
4670")})));
4671end RedeclareTest76;
4672
4673
4674model RedeclareTest77
4675    record R1
4676        constant Real x = 1;
4677        end R1;
4678   
4679    record R2
4680        constant Real x = 2;
4681        constant Real y = 3;
4682        end R2;
4683   
4684    model A
4685        replaceable record R = R1;
4686        R r;
4687        end A;
4688   
4689    A a(redeclare record R = R2);
4690
4691    annotation(__JModelica(UnitTesting(tests={
4692        FlatteningTestCase(
4693            name="RedeclareTest77",
4694            description="Check that automatically generated binding expressions for records of redeclared types use the correct name",
4695            flatModel="
4696fclass RedeclareTests.General.RedeclareTest77
4697 constant RedeclareTests.General.RedeclareTest77.a.R a.r = RedeclareTests.General.RedeclareTest77.a.R(2, 3);
4698
4699public
4700 record RedeclareTests.General.RedeclareTest77.a.R
4701  constant Real x;
4702  constant Real y;
4703 end RedeclareTests.General.RedeclareTest77.a.R;
4704
4705end RedeclareTests.General.RedeclareTest77;
4706")})));
4707end RedeclareTest77;
4708
4709
4710model RedeclareTest78
4711    package P
4712        record R1
4713            Real x = 1;
4714        end R1;
4715       
4716        record R2
4717            extends R1;
4718        end R2;
4719       
4720        model M
4721            R2 r2 = R2();
4722        end M;
4723    end P;
4724   
4725    package P2
4726        extends P;
4727        redeclare record extends R2
4728           
4729        end R2;
4730    end P2;
4731   
4732    P2.M m(r2=P2.R2(2));
4733
4734    annotation(__JModelica(UnitTesting(tests={
4735        FlatteningTestCase(
4736            name="RedeclareTest78",
4737            description="Record constructor of redeclare extend record",
4738            flatModel="
4739fclass RedeclareTests.General.RedeclareTest78
4740 RedeclareTests.General.RedeclareTest78.P2.R2 m.r2 = RedeclareTests.General.RedeclareTest78.P2.R2(2);
4741
4742public
4743 record RedeclareTests.General.RedeclareTest78.P2.R2
4744  Real x;
4745 end RedeclareTests.General.RedeclareTest78.P2.R2;
4746
4747end RedeclareTests.General.RedeclareTest78;
4748")})));
4749end RedeclareTest78;
4750
4751end general;
4752
4753
4754package Element
4755
4756model RedeclareElement1
4757  model A
4758    replaceable model B
4759      Real y;
4760    end B;
4761   
4762    B b;
4763  end A;
4764 
4765  model C
4766    extends A;
4767    redeclare model B = D;
4768    model D
4769      Real y;
4770      Real z;
4771    end D;
4772  end C;
4773 
4774  C c;
4775equation
4776  c.b.y = 1;
4777  c.b.z = 2;
4778
4779        annotation(__JModelica(UnitTesting(tests={
4780                FlatteningTestCase(
4781                        name="RedeclareElement1",
4782                        description="Redeclare class as element, short replacing declaration, basic test",
4783                        flatModel="
4784fclass RedeclareTests.Element.RedeclareElement1
4785 Real c.b.y;
4786 Real c.b.z;
4787equation
4788 c.b.y = 1;
4789 c.b.z = 2;
4790end RedeclareTests.Element.RedeclareElement1;
4791")})));
4792end RedeclareElement1;
4793
4794
4795model RedeclareElement2
4796  model A
4797    replaceable model B
4798      Real y;
4799    end B;
4800   
4801    B b;
4802  end A;
4803 
4804  model C
4805    extends A;
4806    redeclare model B
4807      Real y;
4808      Real z;
4809    end B;
4810  end C;
4811 
4812  C c;
4813equation
4814  c.b.y = 1;
4815  c.b.z = 2;
4816
4817        annotation(__JModelica(UnitTesting(tests={
4818                FlatteningTestCase(
4819                        name="RedeclareElement2",
4820                        description="Redeclare class as element, long replacing declaration, basic test",
4821                        flatModel="
4822fclass RedeclareTests.Element.RedeclareElement2
4823 Real c.b.y;
4824 Real c.b.z;
4825equation
4826 c.b.y = 1;
4827 c.b.z = 2;
4828end RedeclareTests.Element.RedeclareElement2;
4829")})));
4830end RedeclareElement2;
4831
4832
4833model RedeclareElement3
4834  model A
4835    replaceable model B
4836      Real y;
4837    end B;
4838   
4839    B b;
4840  end A;
4841 
4842  model C
4843    extends A;
4844    redeclare model extends B
4845      Real z;
4846    end B;
4847  end C;
4848 
4849  C c;
4850equation
4851  c.b.y = 1;
4852  c.b.z = 2;
4853
4854        annotation(__JModelica(UnitTesting(tests={
4855                FlatteningTestCase(
4856                        name="RedeclareElement3",
4857                        description="Redeclare class as element, long extending declaration, basic test",
4858                        flatModel="
4859fclass RedeclareTests.Element.RedeclareElement3
4860 Real c.b.z;
4861 Real c.b.y;
4862equation
4863 c.b.y = 1;
4864 c.b.z = 2;
4865end RedeclareTests.Element.RedeclareElement3;
4866")})));
4867end RedeclareElement3;
4868
4869
4870model RedeclareElement4
4871  model A
4872    replaceable model B
4873      Real y;
4874    end B;
4875   
4876    B b;
4877  end A;
4878 
4879  model C
4880    extends A;
4881    model extends B
4882      Real z;
4883    end B;
4884  end C;
4885 
4886  C c;
4887equation
4888  c.b.y = 1;
4889  c.b.z = 2;
4890
4891        annotation(__JModelica(UnitTesting(tests={
4892                FlatteningTestCase(
4893                        name="RedeclareElement4",
4894                        description="Redeclare class as element, long extending declaration, basic test",
4895                        flatModel="
4896fclass RedeclareTests.Element.RedeclareElement4
4897 Real c.b.z;
4898 Real c.b.y;
4899equation
4900 c.b.y = 1;
4901 c.b.z = 2;
4902end RedeclareTests.Element.RedeclareElement4;
4903")})));
4904end RedeclareElement4;
4905
4906
4907model RedeclareElement5
4908  model A
4909    replaceable model B
4910      Real y(start=3);
4911    end B;
4912   
4913    B b;
4914  end A;
4915 
4916  model C
4917    extends A;
4918    redeclare model B = D(z(start=1)=2);
4919    model D
4920      Real y(start=2);
4921      Real z(start=4);
4922      Real x(start=5);
4923    equation
4924      x = 3;
4925    end D;
4926  end C;
4927 
4928  C c;
4929equation
4930  c.b.y = 1;
4931
4932        annotation(__JModelica(UnitTesting(tests={
4933                TransformCanonicalTestCase(
4934                        name="RedeclareElement5",
4935                        description="Redeclare class as element, short replacing declaration, with equation and modifications",
4936                        flatModel="
4937fclass RedeclareTests.Element.RedeclareElement5
4938 constant Real c.b.y(start = 2) = 1;
4939 constant Real c.b.z(start = 1) = 2;
4940 constant Real c.b.x(start = 5) = 3;
4941end RedeclareTests.Element.RedeclareElement5;
4942")})));
4943end RedeclareElement5;
4944
4945
4946model RedeclareElement6
4947  model A
4948        replaceable model B
4949          Real y;
4950        end B;
4951       
4952        B b;
4953  end A;
4954 
4955  model C
4956        extends A;
4957        redeclare model B
4958          Real y;
4959          Real z;
4960          Real x;
4961        equation
4962          x = 3;
4963        end B;
4964  end C;
4965 
4966  C c;
4967equation
4968  c.b.y = 1;
4969  c.b.z = 2;
4970
4971        annotation(__JModelica(UnitTesting(tests={
4972                TransformCanonicalTestCase(
4973                        name="RedeclareElement6",
4974                        description="Redeclare class as element, long replacing declaration, with equation",
4975                        flatModel="
4976fclass RedeclareTests.Element.RedeclareElement6
4977 constant Real c.b.y = 1;
4978 constant Real c.b.z = 2;
4979 constant Real c.b.x = 3;
4980end RedeclareTests.Element.RedeclareElement6;
4981")})));
4982end RedeclareElement6;
4983
4984
4985model RedeclareElement7
4986  model A
4987        replaceable model B
4988          Real y = 2;
4989          Real x(start=20);
4990      Real w;
4991    equation
4992      w = 4;
4993        end B;
4994       
4995        B b;
4996  end A;
4997 
4998  model C
4999        extends A;
5000        redeclare model extends B(y(start=10), x=3)
5001          Real z;
5002        equation
5003          z = 1;
5004        end B;
5005  end C;
5006 
5007  C c;
5008
5009        annotation(__JModelica(UnitTesting(tests={
5010                TransformCanonicalTestCase(
5011                        name="RedeclareElement7",
5012                        description="Redeclare class as element, long extending declaration, with equation and modifications",
5013                        flatModel="
5014fclass RedeclareTests.Element.RedeclareElement7
5015 constant Real c.b.z = 1;
5016 constant Real c.b.y(start = 10) = 2;
5017 constant Real c.b.x(start = 20) = 3;
5018 constant Real c.b.w = 4;
5019end RedeclareTests.Element.RedeclareElement7;
5020")})));
5021end RedeclareElement7;
5022
5023
5024model RedeclareElement8
5025  model A
5026        replaceable model B
5027                Real y = 2;
5028                Real x(start=20);
5029                Real w;
5030        equation
5031                w = 4;
5032        end B;
5033       
5034        B b;
5035  end A;
5036 
5037  model C
5038        extends A;
5039        model extends B(y(start=10), x=3)
5040          Real z;
5041        equation
5042          z = 1;
5043        end B;
5044  end C;
5045 
5046  C c;
5047
5048        annotation(__JModelica(UnitTesting(tests={
5049                TransformCanonicalTestCase(
5050                        name="RedeclareElement8",
5051                        description="Redeclare class as element, long extending declaration, with equation and modifications",
5052                        flatModel="
5053fclass RedeclareTests.Element.RedeclareElement8
5054 constant Real c.b.z = 1;
5055 constant Real c.b.y(start = 10) = 2;
5056 constant Real c.b.x(start = 20) = 3;
5057 constant Real c.b.w = 4;
5058end RedeclareTests.Element.RedeclareElement8;
5059")})));
5060end RedeclareElement8;
5061
5062
5063model RedeclareElement9
5064        model A
5065                constant Integer n = 2;
5066                B b;
5067               
5068                replaceable model B
5069                        Real x[n] = {i^2 for i in 1:n};
5070                end B;
5071        end A;
5072       
5073        model C
5074                extends A(n=3);
5075               
5076                redeclare model extends B
5077                        Real y = 2;
5078                end B;
5079        end C;
5080       
5081        C c;
5082
5083        annotation(__JModelica(UnitTesting(tests={
5084                FlatteningTestCase(
5085                        name="RedeclareElement9",
5086                        description="Redeclare class as element, using modified constant",
5087                        flatModel="
5088fclass RedeclareTests.Element.RedeclareElement9
5089 constant Integer c.n = 3;
5090 Real c.b.y = 2;
5091 Real c.b.x[3] = {1 ^ 2, 2 ^ 2, 3 ^ 2};
5092end RedeclareTests.Element.RedeclareElement9;
5093")})));
5094end RedeclareElement9;
5095
5096
5097model RedeclareElement10
5098    package A
5099        replaceable model C = D;
5100    end A;
5101   
5102    package B
5103        extends A;
5104       
5105        redeclare model extends C
5106            parameter Real y = x;
5107        end C;
5108    end B;
5109   
5110    model D
5111        parameter Real x = 1;
5112    end D;
5113   
5114    B.C c;
5115
5116        annotation(__JModelica(UnitTesting(tests={
5117                FlatteningTestCase(
5118                        name="RedeclareElement10",
5119                        description="Redeclaring a short class decl with redeclare class extends",
5120                        flatModel="
5121fclass RedeclareTests.Element.RedeclareElement10
5122 parameter Real c.y = c.x;
5123 parameter Real c.x = 1 /* 1 */;
5124end RedeclareTests.Element.RedeclareElement10;
5125")})));
5126end RedeclareElement10;
5127
5128
5129model RedeclareElement11
5130        model A
5131                replaceable model C = D;
5132                C c;
5133        end A;
5134       
5135        model B
5136                extends A;
5137               
5138                redeclare model extends C
5139                        parameter Real y = x;
5140                end C;
5141        end B;
5142       
5143        model D
5144                parameter Real x = 1;
5145        end D;
5146       
5147        B b;
5148
5149        annotation(__JModelica(UnitTesting(tests={
5150                FlatteningTestCase(
5151                        name="RedeclareElement11",
5152                        description="Redeclaring a short class decl with redeclare class extends",
5153                        flatModel="
5154fclass RedeclareTests.Element.RedeclareElement11
5155 parameter Real b.c.y = b.c.x;
5156 parameter Real b.c.x = 1 /* 1 */;
5157end RedeclareTests.Element.RedeclareElement11;
5158")})));
5159end RedeclareElement11;
5160
5161
5162model RedeclareElement12
5163        package A
5164                replaceable package C
5165                        constant Real a = 1;
5166                end C;
5167               
5168                replaceable package E
5169                        constant Real a = 2;
5170                end E;
5171        end A;
5172       
5173        package B
5174                extends A (redeclare package C = D, redeclare package E = F(a = C.a));
5175        end B;
5176       
5177        package D
5178                extends A.C(a = 3);
5179        end D;
5180       
5181        package F
5182                extends A.E(a = 4);
5183        end F;
5184       
5185        package G
5186                extends B;
5187        end G;
5188       
5189        constant Real a = G.E.a;
5190        parameter Real b = a;
5191
5192        annotation(__JModelica(UnitTesting(tests={
5193                FlatteningTestCase(
5194                        name="RedeclareElement12",
5195                        description="Class modification containing reference to element of the extends it is attached to",
5196                        flatModel="
5197fclass RedeclareTests.Element.RedeclareElement12
5198 constant Real a = 3;
5199 parameter Real b = 3.0 /* 3.0 */;
5200end RedeclareTests.Element.RedeclareElement12;
5201")})));
5202end RedeclareElement12;
5203
5204
5205model RedeclareElement13
5206        package A
5207                constant Real b = 1;
5208               
5209                replaceable package E
5210                        constant Real a = 2;
5211                end E;
5212        end A;
5213       
5214        package B
5215                extends A (redeclare package E = F(a = b));
5216        end B;
5217       
5218        package F
5219                extends A.E(a = 3);
5220        end F;
5221       
5222        package G
5223                extends B;
5224        end G;
5225       
5226        constant Real a = G.E.a;
5227        parameter Real c = a;
5228
5229        annotation(__JModelica(UnitTesting(tests={
5230                FlatteningTestCase(
5231                        name="RedeclareElement13",
5232                        description="Class modification containing reference to element of the extends it is attached to",
5233                        flatModel="
5234fclass RedeclareTests.Element.RedeclareElement13
5235 constant Real a = 1;
5236 parameter Real c = 1.0 /* 1.0 */;
5237end RedeclareTests.Element.RedeclareElement13;
5238")})));
5239end RedeclareElement13;
5240
5241
5242model RedeclareElement14
5243        package A
5244                extends B;
5245               
5246                redeclare model extends D
5247                        Real y;
5248                end D;
5249        end A;
5250       
5251        package B
5252                extends C;
5253        end B;
5254       
5255        package C
5256                replaceable model D
5257                        Real x;
5258                end D;
5259        end C;
5260
5261        A.D d(x = 1, y = 2);
5262
5263        annotation(__JModelica(UnitTesting(tests={
5264                TransformCanonicalTestCase(
5265                        name="RedeclareElement14",
5266                        description="Looking up replacing class through extends",
5267                        flatModel="
5268fclass RedeclareTests.Element.RedeclareElement14
5269 constant Real d.y = 2;
5270 constant Real d.x = 1;
5271end RedeclareTests.Element.RedeclareElement14;
5272")})));
5273end RedeclareElement14;
5274
5275
5276model RedeclareElement15
5277        package A
5278                replaceable model B
5279                        Real x = 1;
5280                end B;
5281        end A;
5282       
5283        package C
5284                extends A;
5285               
5286                function f
5287                        input Real i;
5288                        output Real o;
5289                algorithm
5290                        o := i * 2;
5291                end f;
5292               
5293                redeclare model extends B
5294                        Real y = f(x);
5295                end B;
5296        end C;
5297       
5298        C.B z;
5299
5300        annotation(__JModelica(UnitTesting(tests={
5301                TransformCanonicalTestCase(
5302                        name="RedeclareElement15",
5303                        description="Class declared in same scope as replacing class",
5304                        flatModel="
5305fclass RedeclareTests.Element.RedeclareElement15
5306 constant Real z.y = 2.0;
5307 constant Real z.x = 1;
5308end RedeclareTests.Element.RedeclareElement15;
5309")})));
5310end RedeclareElement15;
5311
5312
5313model RedeclareElement16
5314        package A
5315                replaceable model B
5316                        Real x = 1;
5317                end B;
5318        end A;
5319       
5320        package C
5321                extends A;
5322               
5323                redeclare model B = D.E;
5324        end C;
5325       
5326        package D
5327                function f
5328                        input Real i;
5329                        output Real o;
5330                algorithm
5331                        o := i * 2;
5332                end f;
5333               
5334                model E
5335                        Real x = 1;
5336                        Real y = f(x);
5337                end E;
5338        end D;
5339       
5340        C.B z;
5341
5342        annotation(__JModelica(UnitTesting(tests={
5343                TransformCanonicalTestCase(
5344                        name="RedeclareElement16",
5345                        description="Class declared in same scope as replacing class",
5346                        flatModel="
5347fclass RedeclareTests.Element.RedeclareElement16
5348 constant Real z.x = 1;
5349 constant Real z.y = 2.0;
5350end RedeclareTests.Element.RedeclareElement16;
5351")})));
5352end RedeclareElement16;
5353
5354
5355model RedeclareElement17
5356        package A
5357                replaceable model B
5358                        Real x = 1;
5359                end B;
5360        end A;
5361       
5362        package C
5363                extends A(redeclare model B = D.E);
5364        end C;
5365       
5366        package D
5367                function f
5368                        input Real i;
5369                        output Real o;
5370                algorithm
5371                        o := i * 2;
5372                end f;
5373               
5374                model E
5375                        Real x = 1;
5376                        Real y = f(x);
5377                end E;
5378        end D;
5379       
5380        C.B z;
5381
5382        annotation(__JModelica(UnitTesting(tests={
5383                TransformCanonicalTestCase(
5384                        name="RedeclareElement17",
5385                        description="Class declared in same scope as replacing class",
5386                        flatModel="
5387fclass RedeclareTests.Element.RedeclareElement17
5388 constant Real z.x = 1;
5389 constant Real z.y = 2.0;
5390end RedeclareTests.Element.RedeclareElement17;
5391")})));
5392end RedeclareElement17;
5393
5394
5395model RedeclareElement18
5396    package A
5397        replaceable model B
5398            Real x = 1;
5399        end B;
5400    end A;
5401   
5402    package C
5403        extends A;
5404        redeclare replaceable model extends B
5405            Real y = 2;
5406        end B;
5407    end C;
5408   
5409    package D
5410        extends C;
5411        redeclare replaceable model extends B
5412            Real z = 3;
5413        end B;
5414    end D;
5415   
5416    package E
5417        extends D;
5418        redeclare model extends B
5419            Real w = 4;
5420        end B;
5421    end E;
5422   
5423    E.B f;
5424
5425        annotation(__JModelica(UnitTesting(tests={
5426                FlatteningTestCase(
5427                        name="RedeclareElement18",
5428                        description="Chain of redeclare class extends - packages",
5429                        flatModel="
5430fclass RedeclareTests.Element.RedeclareElement18
5431 Real f.w = 4;
5432 Real f.z = 3;
5433 Real f.y = 2;
5434 Real f.x = 1;
5435end RedeclareTests.Element.RedeclareElement18;
5436")})));
5437end RedeclareElement18;
5438
5439
5440model RedeclareElement19
5441    package A
5442        replaceable model B
5443            Real x = 1;
5444        end B;
5445    end A;
5446   
5447    package C
5448        extends A;
5449    end C;
5450   
5451    package D
5452        extends C;
5453        redeclare replaceable model extends B
5454            Real y = 2;
5455        end B;
5456    end D;
5457   
5458    package E
5459        extends D;
5460    end E;
5461   
5462    package F
5463        extends E;
5464        redeclare model extends B
5465            Real z = 3;
5466        end B;
5467    end F;
5468   
5469    package G
5470        extends F;
5471    end G;
5472   
5473    G.B h;
5474
5475        annotation(__JModelica(UnitTesting(tests={
5476                FlatteningTestCase(
5477                        name="RedeclareElement19",
5478                        description="Chain of redeclare class extends - packages, with extends in between",
5479                        flatModel="
5480fclass RedeclareTests.Element.RedeclareElement19
5481 Real h.z = 3;
5482 Real h.y = 2;
5483 Real h.x = 1;
5484end RedeclareTests.Element.RedeclareElement19;
5485")})));
5486end RedeclareElement19;
5487
5488
5489model RedeclareElement20
5490    model A
5491        replaceable model B
5492            Real x = 1;
5493        end B;
5494               
5495                B g;
5496    end A;
5497   
5498    model C
5499        extends A;
5500        redeclare replaceable model extends B
5501            Real y = 2;
5502        end B;
5503    end C;
5504   
5505    model D
5506        extends C;
5507        redeclare replaceable model extends B
5508            Real z = 3;
5509        end B;
5510    end D;
5511   
5512    model E
5513        extends D;
5514        redeclare model extends B
5515            Real w = 4;
5516        end B;
5517    end E;
5518   
5519    E f;
5520
5521        annotation(__JModelica(UnitTesting(tests={
5522                FlatteningTestCase(
5523                        name="RedeclareElement20",
5524                        description="Chain of redeclare class extends - models",
5525                        flatModel="
5526fclass RedeclareTests.Element.RedeclareElement20
5527 Real f.g.w = 4;
5528 Real f.g.z = 3;
5529 Real f.g.y = 2;
5530 Real f.g.x = 1;
5531end RedeclareTests.Element.RedeclareElement20;
5532")})));
5533end RedeclareElement20;
5534
5535
5536model RedeclareElement21
5537    model A
5538        replaceable model B
5539            Real x = 1;
5540        end B;
5541       
5542        B i;
5543    end A;
5544   
5545    model C
5546        extends A;
5547    end C;
5548   
5549    model D
5550        extends C;
5551        redeclare replaceable model extends B
5552            Real y = 2;
5553        end B;
5554    end D;
5555   
5556    model E
5557        extends D;
5558    end E;
5559   
5560    model F
5561        extends E;
5562        redeclare model extends B
5563            Real z = 3;
5564        end B;
5565    end F;
5566   
5567    model G
5568        extends F;
5569    end G;
5570   
5571    G h;
5572
5573        annotation(__JModelica(UnitTesting(tests={
5574                FlatteningTestCase(
5575                        name="RedeclareElement21",
5576                        description="Chain of redeclare class extends - models, with extends in between",
5577                        flatModel="
5578fclass RedeclareTests.Element.RedeclareElement21
5579 Real h.i.z = 3;
5580 Real h.i.y = 2;
5581 Real h.i.x = 1;
5582end RedeclareTests.Element.RedeclareElement21;
5583")})));
5584end RedeclareElement21;
5585
5586
5587model RedeclareElement22
5588  package A
5589    replaceable model B
5590      Real y = 1;
5591    end B;
5592   
5593    B b;
5594  end A;
5595 
5596  package C
5597    extends A;
5598    redeclare model extends B
5599      Real z = 2;
5600    end B;
5601  end C;
5602 
5603  model D
5604    replaceable model E
5605    end E;
5606
5607    E e;
5608  end D;
5609
5610  model F
5611    extends D(redeclare final model E = C.B);
5612  end F;
5613 
5614  F f;
5615
5616        annotation(__JModelica(UnitTesting(tests={
5617                TransformCanonicalTestCase(
5618                        name="RedeclareElement22",
5619                        description="Redeclare class extends used directly in redeclare",
5620                        flatModel="
5621fclass RedeclareTests.Element.RedeclareElement22
5622 constant Real f.e.z = 2;
5623 constant Real f.e.y = 1;
5624end RedeclareTests.Element.RedeclareElement22;
5625")})));
5626end RedeclareElement22;
5627
5628
5629model RedeclareElement23
5630  package A
5631    replaceable model B
5632      Real y = 1;
5633    end B;
5634   
5635    B b;
5636  end A;
5637 
5638  package C
5639    extends A;
5640    redeclare model extends B
5641      Real z = 2;
5642    end B;
5643  end C;
5644 
5645  C.B[2] b;
5646  Real x = b[1].y;
5647
5648        annotation(__JModelica(UnitTesting(tests={
5649                TransformCanonicalTestCase(
5650                        name="RedeclareElement23",
5651                        description="Array of redeclare class extends",
5652            eliminate_alias_variables=false,
5653                        flatModel="
5654fclass RedeclareTests.Element.RedeclareElement23
5655 constant Real b[1].z = 2;
5656 constant Real b[1].y = 1;
5657 constant Real b[2].z = 2;
5658 constant Real b[2].y = 1;
5659 constant Real x = 1.0;
5660end RedeclareTests.Element.RedeclareElement23;
5661")})));
5662end RedeclareElement23;
5663
5664
5665model RedeclareElement24
5666        partial function A
5667        input Real x;
5668        output Real y;
5669        end A;
5670       
5671        function B
5672        extends A;
5673    algorithm
5674        y := x;
5675    end B;
5676       
5677        partial record C
5678        replaceable function D = A;
5679    end C;
5680       
5681        record E
5682        extends C(redeclare function D = B);
5683    end E;
5684       
5685        model F
5686                replaceable function G = A;
5687                Real x = 1;
5688        end F;
5689       
5690        model H
5691                replaceable record I = C;
5692        function J = I.D;
5693                replaceable function K = J;
5694                F b(redeclare function G = K);
5695        end H;
5696       
5697        H a(redeclare record I = E);
5698
5699        annotation(__JModelica(UnitTesting(tests={ 
5700                FlatteningTestCase(
5701                        name="RedeclareElement24",
5702                        description="Complex system of redeclares that caused erroneous error message",
5703                        flatModel="
5704fclass RedeclareTests.Element.RedeclareElement24
5705 Real a.b.x = 1;
5706end RedeclareTests.Element.RedeclareElement24;
5707")})));
5708end RedeclareElement24;
5709
5710
5711model RedeclareElement25
5712    package A
5713        extends F(redeclare model C = D);
5714    end A;
5715   
5716    package F
5717        replaceable model C = E;
5718    end F;
5719   
5720    model E
5721        replaceable package B = F;
5722        Real x = 1;
5723    end E;
5724   
5725    model D
5726        extends E(redeclare replaceable package B = A);
5727    end D;
5728   
5729    A.C a;
5730
5731        annotation(__JModelica(UnitTesting(tests={ 
5732                FlatteningTestCase(
5733                        name="RedeclareElement25",
5734                        description="Causes recursive class structure that expands infinitely if classes are expanded",
5735                        flatModel="
5736fclass RedeclareTests.Element.RedeclareElement25
5737 Real a.x = 1;
5738end RedeclareTests.Element.RedeclareElement25;
5739")})));
5740end RedeclareElement25;
5741
5742model RedeclareElement26
5743        record RA
5744                Real a = 2;
5745        end RB;
5746        record RB
5747                extends RA(a = 1);
5748        end RB;
5749       
5750        model B
5751                replaceable record R = RA;
5752                R r;
5753                Real x;
5754        equation
5755                x = r.a;
5756        end B;
5757        B b(redeclare record R = RB);
5758        annotation(__JModelica(UnitTesting(tests={ 
5759                FlatteningTestCase(
5760                        name="RedeclareElement26",
5761                        description="Redeclare of records",
5762                        flatModel="
5763fclass RedeclareTests.Element.RedeclareElement26
5764 RedeclareTests.Element.RedeclareElement26.b.R b.r(a = 1);
5765 Real b.x;
5766equation
5767 b.x = b.r.a;
5768
5769public
5770 record RedeclareTests.Element.RedeclareElement26.b.R
5771  Real a;
5772 end RedeclareTests.Element.RedeclareElement26.b.R;
5773
5774end RedeclareTests.Element.RedeclareElement26;
5775")})));
5776end RedeclareElement26;
5777
5778
5779model RedeclareElement27
5780    package A
5781        model B
5782            extends C;
5783            redeclare parameter D x = 1;
5784        end B;
5785       
5786        model C
5787            replaceable D x;
5788        end C;
5789       
5790        type D = Real;
5791    end A;
5792   
5793    A.B b;
5794
5795    annotation(__JModelica(UnitTesting(tests={
5796        FlatteningTestCase(
5797            name="RedeclareElement27",
5798            description="Check that class lookup goes the correct path from element redeclares",
5799            flatModel="
5800fclass RedeclareTests.Element.RedeclareElement27
5801 parameter Real b.x = 1 /* 1 */;
5802end RedeclareTests.Element.RedeclareElement27;
5803")})));
5804end RedeclareElement27;
5805
5806
5807model RedeclareElement28
5808    package A
5809        model B
5810            extends C;
5811            redeclare parameter D x = 1;
5812        end B;
5813       
5814        model C
5815            replaceable D x;
5816        end C;
5817       
5818        type D = Real;
5819    end A;
5820   
5821    model E
5822        extends A.B;
5823    end E;
5824   
5825    E e;
5826
5827    annotation(__JModelica(UnitTesting(tests={
5828        FlatteningTestCase(
5829            name="RedeclareElement28",
5830            description="Check that class lookup goes the correct path from element redeclares",
5831            flatModel="
5832fclass RedeclareTests.Element.RedeclareElement28
5833 parameter Real e.x = 1 /* 1 */;
5834end RedeclareTests.Element.RedeclareElement28;
5835")})));
5836end RedeclareElement28;
5837
5838
5839model RedeclareSameLevel10
5840        package A
5841                replaceable partial model C
5842                end C;
5843               
5844                replaceable model D
5845                        C c;
5846                end D;
5847        end A;
5848       
5849        package B
5850                extends A;
5851               
5852                redeclare model C
5853                        Real x;
5854                end C;
5855
5856                redeclare model extends D
5857                        Real y;
5858                end D;
5859        end B;
5860       
5861        B.D d;
5862equation
5863        d.c.x = 1;
5864        d.y = 2;
5865
5866        annotation(__JModelica(UnitTesting(tests={
5867                FlatteningTestCase(
5868                        name="RedeclareSameLevel10",
5869                        description="Class used in base class redeclared as element",
5870                        flatModel="
5871fclass RedeclareTests.Element.RedeclareSameLevel10
5872 Real d.y;
5873 Real d.c.x;
5874equation
5875 d.c.x = 1;
5876 d.y = 2;
5877end RedeclareTests.Element.RedeclareSameLevel10;
5878")})));
5879end RedeclareSameLevel10;
5880
5881
5882model RedeclareSameLevel11
5883        package A
5884                replaceable model C
5885                        Real x;
5886                end C;
5887               
5888                model D
5889                        C c;
5890                end D;
5891        end A;
5892       
5893        package B
5894                extends A;
5895               
5896                redeclare model extends C
5897                        Real y;
5898                end C;
5899        end B;
5900       
5901        B.D d;
5902equation
5903        d.c.x = 1;
5904        d.c.y = 2;
5905
5906        annotation(__JModelica(UnitTesting(tests={
5907                FlatteningTestCase(
5908                        name="RedeclareSameLevel11",
5909                        description="Class used in base class redeclared as element",
5910                        flatModel="
5911fclass RedeclareTests.Element.RedeclareSameLevel11
5912 Real d.c.y;
5913 Real d.c.x;
5914equation
5915 d.c.x = 1;
5916 d.c.y = 2;
5917end RedeclareTests.Element.RedeclareSameLevel11;
5918")})));
5919end RedeclareSameLevel11;
5920
5921
5922model RedeclareSameLevel12
5923        package A
5924                replaceable partial model C
5925                end C;
5926               
5927                replaceable model D
5928                        C c;
5929                end D;
5930        end A;
5931       
5932        package B
5933                extends A;
5934               
5935                redeclare model C
5936                        Real x;
5937                end C;
5938
5939                redeclare model extends D
5940                        Real y;
5941                equation
5942                        c.x = 1;
5943                        y = 2;
5944                end D;
5945        end B;
5946       
5947        B.D d;
5948
5949        annotation(__JModelica(UnitTesting(tests={
5950                FlatteningTestCase(
5951                        name="RedeclareSameLevel12",
5952                        description="Two interdependent classes redeclared as elements, with inner equations",
5953                        flatModel="
5954fclass RedeclareTests.Element.RedeclareSameLevel12
5955 Real d.y;
5956 Real d.c.x;
5957equation
5958 d.c.x = 1;
5959 d.y = 2;
5960end RedeclareTests.Element.RedeclareSameLevel12;
5961")})));
5962end RedeclareSameLevel12;
5963
5964end Element;
5965
5966package Function
5967
5968model RedeclareFunction1
5969        package A
5970                constant Integer n = 1;
5971                replaceable partial function B
5972                        input Real i[n];
5973                        output Real o[n];
5974                end B;
5975        end A;
5976       
5977        package C
5978                extends A(n = 2);
5979               
5980                redeclare function extends B
5981                algorithm
5982                        o := i;
5983                end B;
5984        end C;
5985       
5986        Real x[2] = C.B({1, 2});
5987
5988        annotation(__JModelica(UnitTesting(tests={
5989                FlatteningTestCase(
5990                        name="RedeclareFunction1",
5991                        description="Lookup with modifications in extending function",
5992                        flatModel="
5993fclass RedeclareTests.Function.RedeclareFunction1
5994 Real x[2] = RedeclareTests.Function.RedeclareFunction1.C.B({1,2});
5995
5996public
5997 function RedeclareTests.Function.RedeclareFunction1.C.B
5998  input Real[:] i;
5999  output Real[:] o;
6000 algorithm
6001  assert(2 == size(i, 1), \"Mismatching sizes in function 'RedeclareTests.Function.RedeclareFunction1.C.B', component 'i', dimension '1'\");
6002  init o as Real[2];
6003  o[1:2] := i[1:2];
6004  return;
6005 end RedeclareTests.Function.RedeclareFunction1.C.B;
6006
6007end RedeclareTests.Function.RedeclareFunction1;
6008")})));
6009end RedeclareFunction1;
6010
6011
6012model RedeclareFunction2
6013        package A
6014                constant Integer n = 1;
6015               
6016                replaceable partial function B
6017                        input Real i[n];
6018                        output D o;
6019                end B;
6020               
6021                replaceable partial record D
6022                end D;
6023        end A;
6024       
6025        package C
6026                extends A(n = 2);
6027               
6028                redeclare function extends B
6029                algorithm
6030                        o.a := i;
6031                end B;
6032
6033                redeclare record D
6034                        Real a[n];
6035                end D;
6036        end C;
6037       
6038        C.D x = C.B({1, 2});
6039
6040        annotation(__JModelica(UnitTesting(tests={
6041                FlatteningTestCase(
6042                        name="RedeclareFunction2",
6043                        description="Lookup in extending function with redeclared record",
6044                        flatModel="
6045fclass RedeclareTests.Function.RedeclareFunction2
6046 RedeclareTests.Function.RedeclareFunction2.C.D x(a(size() = {2})) = RedeclareTests.Function.RedeclareFunction2.C.B({1, 2});
6047
6048public
6049 function RedeclareTests.Function.RedeclareFunction2.C.B
6050  input Real[:] i;
6051  output RedeclareTests.Function.RedeclareFunction2.C.D o;
6052 algorithm
6053  assert(2 == size(i, 1), \"Mismatching sizes in function 'RedeclareTests.Function.RedeclareFunction2.C.B', component 'i', dimension '1'\");
6054  o.a[1:2] := i[1:2];
6055  return;
6056 end RedeclareTests.Function.RedeclareFunction2.C.B;
6057
6058 record RedeclareTests.Function.RedeclareFunction2.C.D
6059  Real a[2];
6060 end RedeclareTests.Function.RedeclareFunction2.C.D;
6061
6062end RedeclareTests.Function.RedeclareFunction2;
6063")})));
6064end RedeclareFunction2;
6065
6066
6067model RedeclareFunction3
6068        package A
6069                extends B;
6070                redeclare model extends C(redeclare package D = E)
6071                        Real x = D.f(y);
6072                end C;
6073        end A;
6074       
6075        package B
6076                replaceable model C
6077                        replaceable package D = F;
6078                        Real y = 1;
6079                end C;
6080        end B;
6081       
6082        package E
6083                extends F;
6084               
6085                redeclare function extends f
6086                algorithm
6087                        o := i * 2;
6088                end f;
6089        end E;
6090       
6091        package F
6092                replaceable function f
6093                        input Real i;
6094                        output Real o;
6095                end f;
6096        end F;
6097
6098        A.C z;
6099
6100        annotation(__JModelica(UnitTesting(tests={
6101                TransformCanonicalTestCase(
6102                        name="RedeclareFunction3",
6103                        description="Functions redeclared in replacing package",
6104                        flatModel="
6105fclass RedeclareTests.Function.RedeclareFunction3
6106 constant Real z.x = 2.0;
6107 constant Real z.y = 1;
6108end RedeclareTests.Function.RedeclareFunction3;
6109")})));
6110end RedeclareFunction3;
6111
6112
6113
6114model RedeclareFunction4
6115    package A
6116        constant Integer n = 2;
6117        function f
6118            input Real a[n];
6119            output Real b;
6120        algorithm
6121            b := a * (1:n);
6122        end f;
6123    end A;
6124   
6125    model B
6126        package A2 = A;
6127        package A3 = A(n = 3);
6128       
6129        Real x = A2.f(1.0:2.0);
6130        Real y = A3.f(1.0:3.0);
6131    end B;
6132   
6133    B b;
6134
6135        annotation(__JModelica(UnitTesting(tests={
6136                TransformCanonicalTestCase(
6137                        name="RedeclareFunction4",
6138                        description="Redeclared versions of same function",
6139                        flatModel="
6140fclass RedeclareTests.Function.RedeclareFunction4
6141 constant Real b.x = 5.0;
6142 constant Real b.y = 14.0;
6143end RedeclareTests.Function.RedeclareFunction4;
6144")})));
6145end RedeclareFunction4;
6146
6147
6148model RedeclareFunction5
6149    model A
6150      B b(redeclare replaceable function f4 = f3);
6151      function f3 = f2(z = p1);
6152      parameter Real p1 = 1;
6153    end A;
6154
6155    model B
6156      C c(redeclare function f5 = f4);
6157      replaceable function f4 = f2(z = p2);
6158      parameter Real p2 = 2;
6159    end B;
6160
6161    model C
6162      replaceable function f5 = f1;
6163      Real y = f5(x);
6164      Real x = time;
6165    end C;
6166   
6167    function f1
6168        input Real x;
6169        output Real y;
6170    end f1;
6171   
6172    function f2
6173        extends f1;
6174        input Real z;
6175    algorithm
6176        y := x + z;
6177    end f2;
6178
6179    A a;
6180
6181    annotation(__JModelica(UnitTesting(tests={
6182        FlatteningTestCase(
6183            name="RedeclareFunction5",
6184            description="Flattening of default value of function input from modification on constraining type",
6185            flatModel="
6186fclass RedeclareTests.Function.RedeclareFunction5
6187 Real a.b.c.y = RedeclareTests.Function.RedeclareFunction5.a.b.f4(a.b.c.x, a.b.p2);
6188 Real a.b.c.x = time;
6189 parameter Real a.b.p2 = 2 /* 2 */;
6190 parameter Real a.p1 = 1 /* 1 */;
6191
6192public
6193 function RedeclareTests.Function.RedeclareFunction5.a.b.f4
6194  input Real x;
6195  output Real y;
6196  input Real z;
6197 algorithm
6198  y := x + z;
6199  return;
6200 end RedeclareTests.Function.RedeclareFunction5.a.b.f4;
6201
6202end RedeclareTests.Function.RedeclareFunction5;
6203")})));
6204end RedeclareFunction5;
6205
6206end Function;
6207
6208package EachFinal
6209
6210model RedeclareEach1
6211    model A
6212        package B = D;
6213        Real a[B.N] = zeros(B.N);
6214    end A;
6215   
6216    package C
6217        extends D(N = 1);
6218    end C;
6219   
6220    package D
6221        constant Integer N = 2;
6222    end D;
6223   
6224    A a[2](redeclare each package B = C);
6225
6226    annotation(__JModelica(UnitTesting(tests={
6227        TransformCanonicalTestCase(
6228            name="RedeclareEach1",
6229            description="Using redeclare on array",
6230            eliminate_alias_variables=false,
6231            flatModel="
6232fclass RedeclareTests.EachFinal.RedeclareEach1
6233 constant Real a[1].a[1] = 0;
6234 constant Real a[2].a[1] = 0;
6235end RedeclareTests.EachFinal.RedeclareEach1;
6236")})));
6237end RedeclareEach1;
6238
6239
6240model RedeclareEach2
6241    model E
6242        package B = D;
6243    end E;
6244   
6245    model A
6246        extends E;
6247        Real a[B.N] = zeros(B.N);
6248    end A;
6249   
6250    package C
6251        extends D(N = 1);
6252    end C;
6253   
6254    package D
6255        constant Integer N = 2;
6256    end D;
6257   
6258    A a[2](redeclare each package B = C);
6259
6260    annotation(__JModelica(UnitTesting(tests={
6261        TransformCanonicalTestCase(
6262            name="RedeclareEach2",
6263            description="Using redeclare on array",
6264            eliminate_alias_variables=false,
6265            flatModel="
6266fclass RedeclareTests.EachFinal.RedeclareEach2
6267 constant Real a[1].a[1] = 0;
6268 constant Real a[2].a[1] = 0;
6269end RedeclareTests.EachFinal.RedeclareEach2;
6270")})));
6271end RedeclareEach2;
6272
6273model FinalRedeclare1
6274    model A
6275    end A;
6276   
6277    model B
6278        parameter Real b = 1;
6279    end B;
6280   
6281    model C
6282        parameter Real c = 2;
6283    end C;
6284   
6285    model D
6286        replaceable A a;
6287    end D;
6288   
6289    model E
6290        extends D(redeclare B a);
6291    end E;
6292   
6293    model F
6294        extends E(redeclare C a);
6295    end F;
6296   
6297    F f;
6298
6299    annotation(__JModelica(UnitTesting(tests={
6300        WarningTestCase(
6301            name="FinalRedeclare1",
6302            description="Check that final redeclares are enforced for modification component redeclares",
6303            errorMessage="
63041 warnings found:
6305
6306Warning at line 22, column 19, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', PREV_REDECLARE_NOT_REPLACEABLE,
6307In component f:
6308  In the declaration 'redeclare C a', a can't be redeclared since it has already been redeclared without 'replaceable'
6309")})));
6310end FinalRedeclare1;
6311
6312
6313model FinalRedeclare2
6314    model A
6315    end A;
6316   
6317    model B
6318        parameter Real b = 1;
6319    end B;
6320   
6321    model C
6322        parameter Real c = 2;
6323    end C;
6324   
6325    model D
6326        replaceable A a;
6327    end D;
6328   
6329    model E
6330        extends D;
6331        redeclare B a;
6332    end E;
6333   
6334    model F
6335        extends E;
6336        redeclare C a;
6337    end F;
6338   
6339    F f;
6340
6341    annotation(__JModelica(UnitTesting(tests={
6342        WarningTestCase(
6343            name="FinalRedeclare2",
6344            description="Check that final redeclares are enforced for element component redeclares",
6345            errorMessage="
63461 warnings found:
6347
6348Warning at line 24, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo', PREV_REDECLARE_NOT_REPLACEABLE:
6349  In the declaration 'redeclare C a', a can't be redeclared since it has already been redeclared without 'replaceable'
6350")})));
6351end FinalRedeclare2;
6352
6353
6354// TODO: Does not generate an error - seem like redeclared classes aren't error checked at all.
6355//       Add this test once #5088 is fixed.
6356model FinalRedeclare3
6357    model A
6358    end A;
6359   
6360    model B
6361        parameter Real b = 1;
6362    end B;
6363   
6364    model C
6365        parameter Real c = 2;
6366    end C;
6367   
6368    model D
6369        replaceable model G = A;
6370        G g;
6371    end D;
6372   
6373    model E
6374        extends D(redeclare model G = B);
6375    end E;
6376   
6377    model F
6378        extends E(redeclare model G = C);
6379    end F;
6380   
6381    F f;
6382end FinalRedeclare3;
6383
6384end EachFinal;
6385
6386package Misc
6387
6388
6389// When looking up the class H.D extends (E.D) from the redeclaration in A,
6390// InstReplacingFullClassDecl.doSurroundingSuperLookupInstClass returns B, but should
6391// lookup from H.D instead
6392model ShortRedeclare1
6393    package A
6394        replaceable function B
6395            output Real c = 2;
6396        end B;
6397    end A;
6398   
6399    package C = A(redeclare function B = F.D);
6400    package F = H;
6401   
6402    package H
6403        extends E;
6404          redeclare function extends D
6405        algorithm
6406            c := b;
6407        end D;
6408    end H;
6409   
6410    package E
6411        replaceable function D
6412            input Real b = 1;
6413            output Real c;
6414        end D;
6415    end E;
6416   
6417    Real x = C.B();
6418end ShortRedeclare1;
6419
6420
6421model CyclicRedeclare1
6422        package A
6423                replaceable model B = C;
6424        end A;
6425       
6426        model C
6427                Real x = 1;
6428        end C;
6429   
6430    package D
6431        extends A;
6432        redeclare model B = E.B;
6433    end D;
6434   
6435    package E
6436        extends A;
6437        redeclare model B = D.B;
6438    end E;
6439       
6440        E.B b;
6441end CyclicRedeclare1;
6442
6443
6444model ModifyClass1
6445    package A
6446        package B
6447            constant Real x = 1;
6448        end B;
6449    end A;
6450   
6451    package C = A(B(x = 2));
6452   
6453    Real y = C.B.x;
6454        Real Z = A.B.x;
6455
6456        annotation(__JModelica(UnitTesting(tests={
6457                FlatteningTestCase(
6458                        name="ModifyClass1",
6459                        description="Modification of constant in sub-package",
6460                        flatModel="
6461fclass RedeclareTests.Misc.ModifyClass1
6462 Real y = 2.0;
6463 Real Z = 1.0;
6464end RedeclareTests.Misc.ModifyClass1;
6465")})));
6466end ModifyClass1;
6467
6468
6469model ModifyClass2
6470    package A
6471        type B = Real(max = 1);
6472    end A;
6473   
6474    package C = A(B(max = 2));
6475   
6476    C.B y = 0;
6477        A.B z = 0;
6478
6479        annotation(__JModelica(UnitTesting(tests={
6480                FlatteningTestCase(
6481                        name="ModifyClass2",
6482                        description="Modification of attribute of type declared in package being modified",
6483                        flatModel="
6484fclass RedeclareTests.Misc.ModifyClass2
6485 RedeclareTests.Misc.ModifyClass2.C.B y(max = 2) = 0;
6486 RedeclareTests.Misc.ModifyClass2.A.B z = 0;
6487
6488public
6489 type RedeclareTests.Misc.ModifyClass2.C.B = Real(max = 2);
6490 type RedeclareTests.Misc.ModifyClass2.A.B = Real(max = 1);
6491end RedeclareTests.Misc.ModifyClass2;
6492")})));
6493end ModifyClass2;
6494
6495
6496model ShortClassDeclEqu1
6497    model A
6498        Real x;
6499    equation
6500        x = y;
6501    end A;
6502   
6503    model B = A;
6504   
6505    B a;
6506
6507    annotation(__JModelica(UnitTesting(tests={
6508        ErrorTestCase(
6509            name="ShortClassDeclEqu1",
6510            description="Make sure equations in instances of short class decls are checked",
6511            errorMessage="
65121 errors found:
6513
6514Error at line 5, column 13, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo',
6515In component a:
6516  Cannot find class or component declaration for y
6517")})));
6518end ShortClassDeclEqu1;
6519
6520
6521model ShortClassDeclEqu2Extra
6522    Real x;
6523equation
6524    x = y;
6525end ShortClassDeclEqu2Extra;
6526
6527model ShortClassDeclEqu2 = ShortClassDeclEqu2Extra
6528
6529    annotation(__JModelica(UnitTesting(tests={
6530        ErrorTestCase(
6531            name="ShortClassDeclEqu2",
6532            description="Make sure equations in short class decls being instantiated are checked",
6533            errorMessage="
65341 errors found:
6535
6536Error at line -2, column 9, in file 'Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo':
6537  Cannot find class or component declaration for y
6538")})));
6539
6540
6541model ShortClassDeclClass1
6542        model A
6543                replaceable function B = C;
6544               
6545                Real x = B(y);
6546                Real y = 1;
6547        end A;
6548       
6549        partial function C
6550                input Real z;
6551                output Real w;
6552        end C;
6553       
6554        model D
6555                replaceable function E = C;
6556               
6557                A a(redeclare function B = E);
6558        end D;
6559       
6560        model F
6561            replaceable record G
6562                        replaceable function H = C;
6563            end G;
6564                replaceable function I = G.H;
6565               
6566                D d(redeclare function E = I);
6567        end F;
6568       
6569        function J
6570        extends C;
6571    algorithm
6572        w := z;
6573        end J;
6574       
6575        record K
6576                function H = J;
6577        end K;
6578       
6579        F f(redeclare record G = K);
6580
6581        annotation(__JModelica(UnitTesting(tests={
6582                FlatteningTestCase(
6583                        name="ShortClassDeclClass1",
6584                        description="Lookup through short class decl with replacing short class decls above and below",
6585                        flatModel="
6586fclass RedeclareTests.Misc.ShortClassDeclClass1
6587 Real f.d.a.x = RedeclareTests.Misc.ShortClassDeclClass1.J(f.d.a.y);
6588 Real f.d.a.y = 1;
6589
6590public
6591 function RedeclareTests.Misc.ShortClassDeclClass1.J
6592  input Real z;
6593  output Real w;
6594 algorithm
6595  w := z;
6596  return;
6597 end RedeclareTests.Misc.ShortClassDeclClass1.J;
6598
6599end RedeclareTests.Misc.ShortClassDeclClass1;
6600")})));
6601end ShortClassDeclClass1;
6602
6603
6604model RedeclareConditional1
6605    model A
6606        parameter Boolean use_b;
6607        B b if use_b;
6608    end A;
6609   
6610    model B
6611        Real x = time;
6612    end B;
6613   
6614    model C
6615        extends B;
6616        Real y = x + 1;
6617    end C;
6618   
6619    A a(use_b = false, redeclare C b);
6620
6621annotation(__JModelica(UnitTesting(tests={
6622    FlatteningTestCase(
6623        name="Misc_RedeclareConditional1",
6624        description="Redeclaring inactive conditional as modification",
6625        flatModel="
6626fclass RedeclareTests.Misc.RedeclareConditional1
6627 structural parameter Boolean a.use_b = false /* false */;
6628end RedeclareTests.Misc.RedeclareConditional1;
6629")})));
6630end RedeclareConditional1;
6631
6632
6633model RedeclareConditional2
6634    model A
6635        parameter Boolean use_b;
6636        B b if use_b;
6637    end A;
6638   
6639    model B
6640        Real x = time;
6641    end B;
6642   
6643    model C
6644        extends B;
6645        Real y = x + 1;
6646    end C;
6647   
6648    model D
6649        extends A(use_b = false);
6650        redeclare C b;
6651    end D;
6652   
6653    D d;
6654
6655annotation(__JModelica(UnitTesting(tests={
6656    FlatteningTestCase(
6657        name="Misc_RedeclareConditional2",
6658        description="Redeclaring inactive conditional as element",
6659        flatModel="
6660fclass RedeclareTests.Misc.RedeclareConditional2
6661 structural parameter Boolean d.use_b = false /* false */;
6662end RedeclareTests.Misc.RedeclareConditional2;
6663")})));
6664end RedeclareConditional2;
6665
6666
6667model RedeclarePrimitive1
6668    model A
6669        replaceable Real x;
6670    end A;
6671   
6672    type B = Real(unit="V");
6673   
6674    A a(redeclare B x);
6675
6676    annotation(__JModelica(UnitTesting(tests={
6677        FlatteningTestCase(
6678            name="RedeclarePrimitive1",
6679            description="Subtyping of primitive variables",
6680            flatModel="
6681fclass RedeclareTests.Misc.RedeclarePrimitive1
6682 RedeclareTests.Misc.RedeclarePrimitive1.B a.x;
6683
6684public
6685 type RedeclareTests.Misc.RedeclarePrimitive1.B = Real(unit = \"V\");
6686end RedeclareTests.Misc.RedeclarePrimitive1;
6687")})));
6688end RedeclarePrimitive1;
6689
6690
6691model ExternalObjectInConstrainingType1
6692        model EO
6693            extends ExternalObject;
6694            function constructor
6695                output EO eo;
6696                external;
6697            end constructor;
6698           
6699            function destructor
6700                input EO eo;
6701                external;
6702            end destructor;
6703        end EO;
6704       
6705        model A
6706            Real x;
6707            EO eo = EO();
6708        end A;
6709       
6710        model B
6711            Real x = time;
6712            EO eo = EO();
6713        end B;
6714       
6715        replaceable B b constrainedby A;
6716
6717    annotation(__JModelica(UnitTesting(tests={
6718        FlatteningTestCase(
6719            name="ExternalObjectInConstrainingType1",
6720            description="",
6721            flatModel="
6722fclass RedeclareTests.Misc.ExternalObjectInConstrainingType1
6723 Real b.x = time;
6724 parameter RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO b.eo = RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO.constructor() /* {} */;
6725
6726public
6727 function RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO.destructor
6728  input RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO eo;
6729 algorithm
6730  external \"C\" destructor(eo);
6731  return;
6732 end RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO.destructor;
6733
6734 function RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO.constructor
6735  output RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO eo;
6736 algorithm
6737  external \"C\" eo = constructor();
6738  return;
6739 end RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO.constructor;
6740
6741 type RedeclareTests.Misc.ExternalObjectInConstrainingType1.EO = ExternalObject;
6742end RedeclareTests.Misc.ExternalObjectInConstrainingType1;
6743")})));
6744end ExternalObjectInConstrainingType1;
6745
6746model ExternalObjectInConstrainingType2
6747    // This one should give an error?
6748        model EO1
6749            extends ExternalObject;
6750            function constructor
6751                output EO1 eo;
6752                external;
6753            end constructor;
6754           
6755            function destructor
6756                input EO1 eo;
6757                external;
6758            end destructor;
6759        end EO1;
6760       
6761        model EO2
6762            extends ExternalObject;
6763            function constructor
6764                output EO2 eo;
6765                external;
6766            end constructor;
6767           
6768            function destructor
6769                input EO2 eo;
6770                external;
6771            end destructor;
6772        end EO2;
6773       
6774        model A
6775            Real x;
6776            EO1 eo = EO1();
6777        end A;
6778       
6779        model B
6780            Real x = time;
6781            EO2 eo = EO2();
6782        end B;
6783       
6784        replaceable B b constrainedby A;
6785
6786    annotation(__JModelica(UnitTesting(tests={
6787        FlatteningTestCase(
6788            name="ExternalObjectInConstrainingType2",
6789            description="",
6790            flatModel="
6791fclass RedeclareTests.Misc.ExternalObjectInConstrainingType2
6792 Real b.x = time;
6793 parameter RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2 b.eo = RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2.constructor() /* {} */;
6794
6795public
6796 function RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2.destructor
6797  input RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2 eo;
6798 algorithm
6799  external \"C\" destructor(eo);
6800  return;
6801 end RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2.destructor;
6802
6803 function RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2.constructor
6804  output RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2 eo;
6805 algorithm
6806  external \"C\" eo = constructor();
6807  return;
6808 end RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2.constructor;
6809
6810 type RedeclareTests.Misc.ExternalObjectInConstrainingType2.EO2 = ExternalObject;
6811end RedeclareTests.Misc.ExternalObjectInConstrainingType2;
6812")})));
6813end ExternalObjectInConstrainingType2;
6814
6815
6816model ConstrainingModifiers1
6817    model A
6818        parameter Integer n = 1;
6819    end A;
6820   
6821    model B
6822        replaceable A a constrainedby A(n = 2);
6823    end B;
6824   
6825    model C
6826        extends A;
6827        parameter Real y[n] = {1};
6828    end C;
6829   
6830    model D
6831        extends B(replaceable C a constrainedby C(y = 2:3));
6832    end D;
6833   
6834    D d;
6835
6836    annotation(__JModelica(UnitTesting(tests={
6837        FlatteningTestCase(
6838            name="ConstrainingModifiers1",
6839            description="",
6840            flatModel="
6841fclass RedeclareTests.Misc.ConstrainingModifiers1
6842 parameter Real d.a.y[2] = 2:3 /* { 2, 3 } */;
6843 structural parameter Integer d.a.n = 2 /* 2 */;
6844end RedeclareTests.Misc.ConstrainingModifiers1;
6845")})));
6846end ConstrainingModifiers1;
6847
6848end Misc;
6849
6850package Array
6851
6852model ReplacableArray1
6853    model A
6854        replaceable B b[2];
6855    end A;
6856   
6857    model B
6858        Real x;
6859    end B;
6860   
6861        model C
6862            extends A;
6863            redeclare D b;
6864        end C;
6865   
6866    model D
6867        Real x;
6868        Real y;
6869    end D;
6870   
6871    C c;
6872
6873        annotation(__JModelica(UnitTesting(tests={
6874                FlatteningTestCase(
6875                        name="ReplacableArray1",
6876                        description="Redeclaring array of components as element in subclass, omitting size",
6877                        flatModel="
6878fclass RedeclareTests.Array.ReplacableArray1
6879 Real c.b[1].x;
6880 Real c.b[1].y;
6881 Real c.b[2].x;
6882 Real c.b[2].y;
6883end RedeclareTests.Array.ReplacableArray1;
6884")})));
6885end ReplacableArray1;
6886
6887
6888model ReplacableArray2
6889    model A
6890        replaceable B b[2];
6891    end A;
6892   
6893    model B
6894        Real x;
6895    end B;
6896   
6897        model C
6898            extends A(redeclare D b);
6899        end C;
6900   
6901    model D
6902        Real x;
6903        Real y;
6904    end D;
6905   
6906    C c;
6907
6908        annotation(__JModelica(UnitTesting(tests={
6909                FlatteningTestCase(
6910                        name="ReplacableArray2",
6911                        description="Redeclaring array of components in modification on extends, omitting size",
6912                        flatModel="
6913fclass RedeclareTests.Array.ReplacableArray2
6914 Real c.b[1].x;
6915 Real c.b[1].y;
6916 Real c.b[2].x;
6917 Real c.b[2].y;
6918end RedeclareTests.Array.ReplacableArray2;
6919")})));
6920end ReplacableArray2;
6921
6922
6923model ReplacableArray3
6924    model A
6925        replaceable B b[2];
6926    end A;
6927   
6928    model B
6929        Real x;
6930    end B;
6931   
6932        model C
6933            extends A(redeclare D b[2]);
6934        end C;
6935       
6936    model D
6937        Real x;
6938        Real y;
6939    end D;
6940   
6941    C c;
6942
6943        annotation(__JModelica(UnitTesting(tests={
6944                FlatteningTestCase(
6945                        name="ReplacableArray3",
6946                        description="Redeclaring array of components in modification on extends, including size",
6947                        flatModel="
6948fclass RedeclareTests.Array.ReplacableArray3
6949 Real c.b[1].x;
6950 Real c.b[1].y;
6951 Real c.b[2].x;
6952 Real c.b[2].y;
6953end RedeclareTests.Array.ReplacableArray3;
6954")})));
6955end ReplacableArray3;
6956
6957
6958model ReplacableArray4
6959    model A
6960        replaceable Real x[2];
6961    end A;
6962   
6963    model B
6964        extends A(redeclare Real x(each start = 1));
6965    end B;
6966   
6967    B b;
6968
6969        annotation(__JModelica(UnitTesting(tests={
6970                FlatteningTestCase(
6971                        name="ReplacableArray4",
6972                        description="Redeclare of primitive array ommitting size, with each on modifier on redeclaration",
6973                        flatModel="
6974fclass RedeclareTests.Array.ReplacableArray4
6975 Real b.x[2](each start = 1);
6976end RedeclareTests.Array.ReplacableArray4;
6977")})));
6978end ReplacableArray4;
6979
6980
6981model ReplacableArray5
6982    package A
6983        constant Integer n = 2;
6984               
6985                model B
6986            replaceable Real x[n];
6987            end B;
6988    end A;
6989   
6990    model C
6991        extends A.B(redeclare Real x(each start = 1));
6992    end C;
6993   
6994    C c;
6995
6996        annotation(__JModelica(UnitTesting(tests={
6997                FlatteningTestCase(
6998                        name="ReplacableArray5",
6999                        description="Redeclare of array with size depending on constant not reachable from redeclaration",
7000                        flatModel="
7001fclass RedeclareTests.Array.ReplacableArray5
7002 Real c.x[2](each start = 1);
7003end RedeclareTests.Array.ReplacableArray5;
7004")})));
7005end ReplacableArray5;
7006
7007
7008model ReplacableArray6
7009    model A
7010        replaceable Real x[2];
7011    end A;
7012   
7013    model B
7014        extends A(redeclare Real x(start = 1:2));
7015    end B;
7016   
7017    B b;
7018
7019        annotation(__JModelica(UnitTesting(tests={
7020                FlatteningTestCase(
7021                        name="ReplacableArray6",
7022                        description="Redeclare of primitive array ommitting size, with array modifier on redeclaration",
7023                        flatModel="
7024fclass RedeclareTests.Array.ReplacableArray6
7025 Real b.x[2](start = 1:2);
7026end RedeclareTests.Array.ReplacableArray6;
7027")})));
7028end ReplacableArray6;
7029
7030
7031model ReplacableArray7
7032    model A
7033        replaceable B b[2];
7034    end A;
7035       
7036        model B
7037                Real x;
7038        end B;
7039   
7040    model C
7041        extends A(redeclare B b(x(start = 1:2) = 3:4));
7042    end C;
7043   
7044    C c;
7045
7046        annotation(__JModelica(UnitTesting(tests={
7047                FlatteningTestCase(
7048                        name="ReplacableArray7",
7049                        description="Redeclare of composite array ommitting size, with array modifier on scalar member on redeclaration",
7050                        flatModel="
7051fclass RedeclareTests.Array.ReplacableArray7
7052 Real c.b[1].x(start = (1:2)[1]) = (3:4)[1];
7053 Real c.b[2].x(start = (1:2)[2]) = (3:4)[2];
7054end RedeclareTests.Array.ReplacableArray7;
7055")})));
7056end ReplacableArray7;
7057
7058end Array;
7059
7060package Prefix
7061
7062model RedeclarePrefix1
7063    model A
7064        inner replaceable Real x = 2;
7065        B b;
7066    end A;
7067   
7068    model B
7069        outer Real x;
7070    end B;
7071   
7072    A a(redeclare Real x=1);
7073
7074    annotation(__JModelica(UnitTesting(tests={
7075        FlatteningTestCase(
7076            name="RedeclarePrefix1",
7077            description="Check that inner/outer is retained from original declaration in a redeclare if none exist in new declaration",
7078            flatModel