Skip to content

Commit d9d58f8

Browse files
volsavolsa
committed
test: add some integration tests
1 parent 23ffab7 commit d9d58f8

File tree

4 files changed

+519
-0
lines changed

4 files changed

+519
-0
lines changed

‎tests/lit/single/polymorphism/chaining.st

Lines changed: 263 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,263 @@
1+
// RUN: (%COMPILE %s && %RUN) | %CHECK %s
2+
3+
FUNCTION_BLOCK A
4+
METHOD printName: STRING
5+
printf('FB A$N');
6+
END_METHOD
7+
8+
METHOD A1
9+
printf(' A::A1$N');
10+
END_METHOD
11+
12+
METHOD A2
13+
printf(' A::A2$N');
14+
END_METHOD
15+
16+
METHOD A3
17+
printf(' A::A3$N');
18+
END_METHOD
19+
20+
METHOD A4
21+
printf(' A::A4$N');
22+
END_METHOD
23+
END_FUNCTION_BLOCK
24+
25+
// B overriddes A2, introduces B1, B2 and B3
26+
FUNCTION_BLOCK B EXTENDS A
27+
METHOD printName: STRING
28+
printf('FB B$N');
29+
END_METHOD
30+
31+
METHOD A2
32+
printf(' B::A2 (overridden)$N');
33+
END_METHOD
34+
35+
METHOD B1
36+
printf(' B::B1$N');
37+
END_METHOD
38+
39+
METHOD B2
40+
printf(' B::B2$N');
41+
END_METHOD
42+
43+
METHOD B3
44+
printf(' B::B3$N');
45+
END_METHOD
46+
END_FUNCTION_BLOCK
47+
48+
// C overriddes A3, B2, introduces C1 and C2
49+
FUNCTION_BLOCK C EXTENDS B
50+
METHOD printName: STRING
51+
printf('FB C$N');
52+
END_METHOD
53+
54+
METHOD A3
55+
printf(' C::A3 (overridden)$N');
56+
END_METHOD
57+
58+
METHOD B2
59+
printf(' C::B2 (overridden)$N');
60+
END_METHOD
61+
62+
METHOD C1
63+
printf(' C::C1$N');
64+
END_METHOD
65+
66+
METHOD C2
67+
printf(' C::C2$N');
68+
END_METHOD
69+
END_FUNCTION_BLOCK
70+
71+
// D overriddes A4, B3, C2, introduces D1
72+
FUNCTION_BLOCK DD EXTENDS C
73+
METHOD printName: STRING
74+
printf('FB D$N');
75+
END_METHOD
76+
77+
METHOD A4
78+
printf(' D::A4 (overridden)$N');
79+
END_METHOD
80+
81+
METHOD B3
82+
printf(' D::B3 (overridden)$N');
83+
END_METHOD
84+
85+
METHOD C2
86+
printf(' D::C2 (overridden)$N');
87+
END_METHOD
88+
89+
METHOD D1
90+
printf(' D::D1$N');
91+
END_METHOD
92+
END_FUNCTION_BLOCK
93+
94+
FUNCTION main
95+
VAR
96+
index: INT;
97+
98+
instanceA: A;
99+
instanceB: B;
100+
instanceC: C;
101+
instanceD: DD;
102+
103+
104+
instanceRefArrayA: ARRAY[1..4] OF POINTER TO A;
105+
instanceRefArrayB: ARRAY[1..3] OF POINTER TO B;
106+
instanceRefArrayC: ARRAY[1..2] OF POINTER TO C;
107+
instanceRefArrayD: ARRAY[1..1] OF POINTER TO DD;
108+
END_VAR
109+
110+
// FIXME:
111+
// TODOs
112+
// - initializer in variable declaration not working, e.g. `instanceRefArrayD: ARRAY[1..1] OF POINTER TO D := [ADR(instanceD)]`
113+
// - initializer in body not working, e.g. `instanceRefArrayD := [ADR(instanceD)]`
114+
instanceA.__vtable := ADR(__vtable_A_instance);
115+
instanceB.__vtable := ADR(__vtable_B_instance);
116+
instanceC.__vtable := ADR(__vtable_C_instance);
117+
instanceD.__vtable := ADR(__vtable_DD_instance);
118+
119+
// Initialize the arrays
120+
instanceRefArrayA[1] := ADR(instanceA);
121+
instanceRefArrayA[2] := ADR(instanceB);
122+
instanceRefArrayA[3] := ADR(instanceC);
123+
instanceRefArrayA[4] := ADR(instanceD);
124+
125+
instanceRefArrayB[1] := ADR(instanceB);
126+
instanceRefArrayB[2] := ADR(instanceC);
127+
instanceRefArrayB[3] := ADR(instanceD);
128+
129+
instanceRefArrayC[1] := ADR(instanceC);
130+
instanceRefArrayC[2] := ADR(instanceD);
131+
132+
instanceRefArrayD[1] := ADR(instanceD);
133+
134+
135+
// CHECK: -- FUNCTION_BLOCK A and its children --
136+
// CHECK: FB A
137+
// CHECK: A::A1
138+
// CHECK: A::A2
139+
// CHECK: A::A3
140+
// CHECK: A::A4
141+
// CHECK: FB B
142+
// CHECK: A::A1
143+
// CHECK: B::A2 (overridden)
144+
// CHECK: A::A3
145+
// CHECK: A::A4
146+
// CHECK: FB C
147+
// CHECK: A::A1
148+
// CHECK: B::A2 (overridden)
149+
// CHECK: C::A3 (overridden)
150+
// CHECK: A::A4
151+
// CHECK: FB D
152+
// CHECK: A::A1
153+
// CHECK: B::A2 (overridden)
154+
// CHECK: C::A3 (overridden)
155+
// CHECK: D::A4 (overridden)
156+
printf('-- FUNCTION_BLOCK A and its children --$N');
157+
FOR index := 1 TO 4 DO
158+
instanceRefArrayA[index]^.printName();
159+
instanceRefArrayA[index]^.A1();
160+
instanceRefArrayA[index]^.A2();
161+
instanceRefArrayA[index]^.A3();
162+
instanceRefArrayA[index]^.A4();
163+
END_FOR
164+
165+
// CHECK: -- FUNCTION_BLOCK B and its children --
166+
// CHECK: FB B
167+
// CHECK: A::A1
168+
// CHECK: B::A2 (overridden)
169+
// CHECK: A::A3
170+
// CHECK: A::A4
171+
// CHECK: B::B1
172+
// CHECK: B::B2
173+
// CHECK: B::B3
174+
// CHECK: FB C
175+
// CHECK: A::A1
176+
// CHECK: B::A2 (overridden)
177+
// CHECK: C::A3 (overridden)
178+
// CHECK: A::A4
179+
// CHECK: B::B1
180+
// CHECK: C::B2 (overridden)
181+
// CHECK: B::B3
182+
// CHECK: FB D
183+
// CHECK: A::A1
184+
// CHECK: B::A2 (overridden)
185+
// CHECK: C::A3 (overridden)
186+
// CHECK: D::A4 (overridden)
187+
// CHECK: B::B1
188+
// CHECK: C::B2 (overridden)
189+
// CHECK: D::B3 (overridden)
190+
printf('$N$N-- FUNCTION_BLOCK B and its children --$N');
191+
FOR index := 1 TO 3 DO
192+
instanceRefArrayB[index]^.printName();
193+
instanceRefArrayB[index]^.A1();
194+
instanceRefArrayB[index]^.A2();
195+
instanceRefArrayB[index]^.A3();
196+
instanceRefArrayB[index]^.A4();
197+
instanceRefArrayB[index]^.B1();
198+
instanceRefArrayB[index]^.B2();
199+
instanceRefArrayB[index]^.B3();
200+
END_FOR
201+
202+
// CHECK: -- FUNCTION_BLOCK C and its children --
203+
// CHECK: FB C
204+
// CHECK: A::A1
205+
// CHECK: B::A2 (overridden)
206+
// CHECK: C::A3 (overridden)
207+
// CHECK: A::A4
208+
// CHECK: B::B1
209+
// CHECK: C::B2 (overridden)
210+
// CHECK: B::B3
211+
// CHECK: C::C1
212+
// CHECK: C::C2
213+
// CHECK: FB D
214+
// CHECK: A::A1
215+
// CHECK: B::A2 (overridden)
216+
// CHECK: C::A3 (overridden)
217+
// CHECK: D::A4 (overridden)
218+
// CHECK: B::B1
219+
// CHECK: C::B2 (overridden)
220+
// CHECK: D::B3 (overridden)
221+
// CHECK: C::C1
222+
// CHECK: D::C2 (overridden)
223+
printf('$N$N-- FUNCTION_BLOCK C and its children --$N');
224+
FOR index := 1 TO 2 DO
225+
instanceRefArrayC[index]^.printName();
226+
instanceRefArrayC[index]^.A1();
227+
instanceRefArrayC[index]^.A2();
228+
instanceRefArrayC[index]^.A3();
229+
instanceRefArrayC[index]^.A4();
230+
instanceRefArrayC[index]^.B1();
231+
instanceRefArrayC[index]^.B2();
232+
instanceRefArrayC[index]^.B3();
233+
instanceRefArrayC[index]^.C1();
234+
instanceRefArrayC[index]^.C2();
235+
END_FOR
236+
237+
// CHECK: -- FUNCTION_BLOCK D and its children (it doesnt have any 😔) --
238+
// CHECK: FB D
239+
// CHECK: A::A1
240+
// CHECK: B::A2 (overridden)
241+
// CHECK: C::A3 (overridden)
242+
// CHECK: D::A4 (overridden)
243+
// CHECK: B::B1
244+
// CHECK: C::B2 (overridden)
245+
// CHECK: D::B3 (overridden)
246+
// CHECK: C::C1
247+
// CHECK: D::C2 (overridden)
248+
// CHECK: D::D1
249+
printf('$N$N-- FUNCTION_BLOCK D and its children (it doesnt have any 😔) --$N');
250+
FOR index := 1 TO 1 DO
251+
instanceRefArrayD[index]^.printName();
252+
instanceRefArrayD[index]^.A1();
253+
instanceRefArrayD[index]^.A2();
254+
instanceRefArrayD[index]^.A3();
255+
instanceRefArrayD[index]^.A4();
256+
instanceRefArrayD[index]^.B1();
257+
instanceRefArrayD[index]^.B2();
258+
instanceRefArrayD[index]^.B3();
259+
instanceRefArrayD[index]^.C1();
260+
instanceRefArrayD[index]^.C2();
261+
instanceRefArrayD[index]^.D1();
262+
END_FOR
263+
END_FUNCTION

‎tests/lit/single/polymorphism/simple.st

Lines changed: 80 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,80 @@
1+
// RUN: (%COMPILE %s && %RUN) | %CHECK %s
2+
3+
FUNCTION_BLOCK A
4+
METHOD foo
5+
printf('A::foo$N');
6+
END_METHOD
7+
8+
METHOD bar
9+
printf('A::bar$N');
10+
END_METHOD
11+
END_FUNCTION_BLOCK
12+
13+
FUNCTION_BLOCK B EXTENDS A
14+
METHOD foo
15+
printf('B::foo (overridden)$N');
16+
END_METHOD
17+
END_FUNCTION_BLOCK
18+
19+
FUNCTION operateOnA
20+
VAR_INPUT
21+
in: POINTER TO A;
22+
END_VAR
23+
24+
in^.foo();
25+
in^.bar();
26+
END_FUNCTION
27+
28+
FUNCTION main
29+
VAR
30+
index: INT;
31+
instanceA: A;
32+
instanceB: B;
33+
instanceRefA: POINTER TO A;
34+
instanceArrayRefA: ARRAY[1..2] OF POINTER TO A;
35+
END_VAR
36+
37+
// FIXME: Missing initialization, these should be part of the __init_<POU>; fix at a later time
38+
instanceA.__vtable := ADR(__vtable_A_instance);
39+
instanceB.__vtable := ADR(__vtable_B_instance);
40+
41+
// ~~ Direct calls ~~
42+
// CHECK: A::foo
43+
// CHECK: A::bar
44+
// CHECK: B::foo (overridden)
45+
// CHECK: A::bar
46+
47+
instanceRefA := ADR(instanceA);
48+
instanceRefA^.foo();
49+
instanceRefA^.bar();
50+
51+
instanceRefA := ADR(instanceB);
52+
instanceRefA^.foo();
53+
instanceRefA^.bar();
54+
55+
// ~~ Indirect calls through arrays ~~
56+
// CHECK: B::foo (overridden)
57+
// CHECK: A::bar
58+
// CHECK: A::foo
59+
// CHECK: A::bar
60+
61+
instanceArrayRefA[1] := ADR(instanceB);
62+
instanceArrayRefA[2] := ADR(instanceA);
63+
FOR index := 1 TO 2 DO
64+
instanceArrayRefA[index]^.foo();
65+
instanceArrayRefA[index]^.bar();
66+
END_FOR
67+
68+
// ~~ Indirect calls through functions ~~
69+
// CHECK: A::foo
70+
// CHECK: A::bar
71+
// CHECK: B::foo (overridden)
72+
// CHECK: A::bar
73+
74+
instanceRefA := ADR(instanceA);
75+
operateOnA(instanceRefA);
76+
77+
instanceRefA := ADR(instanceB);
78+
operateOnA(instanceRefA);
79+
80+
END_FUNCTION

0 commit comments

Comments
 (0)