OopNegativeSemanticTest.ttcn 6.51 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/******************************************************************************
 * Copyright (c) 2000-2021 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
 *
 * Contributors:
 *   Magyari, Miklos
 *
 ******************************************************************************/

module classesNegativeSemantic { 

type component CT {
	port PT pt_PT;
}

type port PT message { inout integer; } with { extension "internal" }

type union MyUnion {
	integer a,
	charstring b
};

type class CorrectClass1 { }

type class BadInheritance extends MyUnion {

}

32
33
34
35
36
37
38
39
40
type class MinimalClass { }
type class @abstract MinimalAbstractClass { }
type class @final MinimalFinalClass { }
type class @trait MinimalTraitClass { }

type class BadExtends extends MinimalClass, MinimalAbstractClass, MinimalFinalClass, MinimalTraitClass {
	// dummy
}

41
type class @trait BadExtends2 extends MinimalClass, MinimalTraitClass {
42
43
44
	// dummy
}

Miklos Magyari's avatar
Miklos Magyari committed
45
type class BadExtends3 extends MinimalFinalClass {
46
47
48
  
}

49
50
51
52
type class @trait BadTraitClass {
	public var integer m_int := 0;
	public timer Timer;
	
Miklos Magyari's avatar
Miklos Magyari committed
53
54
55
56
	create (charstring pl_str) {
		var float vl_float := 1.0;
	}
	
57
58
59
60
61
62
63
	private function f_valid(integer pl_int);
	private function f_invalid(integer pl_int) {
		// this should not be here
	}
	
}

64
65
type class SuperClass {
	var integer vl_a;
66
	template MyUnion t_union := { a := 10 }
67
}
68
 
69
type class SubClass extends SuperClass {
70
	public var integer vl_b;
71
72
73
74
}

type class GrandSubClass extends SubClass {
	var integer vl_c;
75
	template MyUnion t_union2 := { nonexist := 10 }		// non-existing template member
76
77
78
79
80
81
82
83
84
85
86
87
}

type class GrandSubClass2 extends SubClass {
	var charstring vl_b;
}

type class BaseFunctionClass {
	public function f_get_one() return integer {
		return 1; 
	}
}

88
type class OuterClass {
89
	private var integer m_int := 0; 
90
91
92
93
94
95
96

	class NestedClass {
		const charstring c_text := "abc";

		class InnerClass {
			private template MyUnion t_union;
			public var integer badInteger := "xyz";
97
98
99
100
101
102
103
			
			public class EvenDeeper {
				public const charstring chr := "abc";
				
				public class Core {			  
    				public function f_inside(in integer pl_int) return charstring {
    					return this.chr;
104
					}
105
106
				}
			}
107
108
109
110
		}
	}
}

111
112
113
114
115
116
117
118
119
120
type class ReuseClass {
	var charstring vl_orig := "abc";
	
	function f_reuse_id(in integer pl_param) {
		var integer vl_orig := 1;
		vl_orig := 2;
		vl_orig := "abc";	// type mismatch: local definition takes precedence
	}
}

121
122
const integer cg_uninitConst1;

123
124
type class SubFunctionClass extends BaseFunctionClass {  
	private const integer m_const := 1;
125
	private const integer m_uninitConst2;
126
127
128
129
130
	public function f_get_one() return integer {		// FIXME : incomplete marker
		return m_const;
	}
}

131
132
133
134
// an abstract class can have a finally block
type class @abstract FinallyClass {
	public const integer m_const := 0;
} finally {
135
	log(this.m_const);
136
137
138
139
}

// a trait class cannot have a finally block
type class @trait FinallyClass2 {
140
	public function f_pub();
141
} finally {
142
	log(this.m_const);
143
144
}

145
146
147
148
149
// bad combination of class modifiers
type class @final @abstract BadClass1 { }
type class @final @trait BadClass3 { }
type class @abstract @trait BadClass2 { }

150
151
152
// class with this
type class ClassWithThis {
	public var integer vl_a;
153
	public var integer vl_b;
154
155
156
157
158
159
160
161
162

	public function pl_dummy(in integer pl_int) return integer {
		return 1;
	}

	public function f_dummy2(in charstring pl_dummy) {
		var charstring vl_int := this.pl_dummy(1);
	}
	
163
164
165
	create (integer pl_a, float pl_b) { 
		this.vl_a := pl_a;
		this.vl_b := pl_b;
166
167
168
	}
}

169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
function f_fake_super() return charstring {
	return "abc";
}

// bad super references
function f_notinclass(in integer pl_int) {
	var charstring vl_ch := super.f_fake_super();
}

type class FuncClass extends BaseFunctionClass {
	public function f_get_one() return charstring {
		return "xyz";
	}
	
	private function f_test_super() {
	  	// type mismatches 
		var integer vl_int := f_get_one();
		var charstring vl_cs:= super.f_get_one();
	}
188
189
190
191
192
193
	
	public function f_dummy(in integer pl_int) return float {
		return 0.1;
	}
}

194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
// private methods can be overridden in subclass
// protected and public classes can only be overriden with the same formal param list
type class ClassWithPrivate {
	private function f_override(in float pl_float) return integer {
		return 1;
	}

	function f_override2(in float pl_float) return integer {
		return 1;
	}

	public function f_override3(in float pl_float) return integer {
		return 1;
	}
}
 
type class ClassWithPrivateExt extends ClassWithPrivate {
	public function f_override(charstring pl_chr) return charstring {
		return pl_chr;
	}

	public function f_override2(charstring pl_chr) return charstring {
		return pl_chr;
	}

	public function f_override3(charstring pl_chr) return charstring {
		return pl_chr;
	}
}

Miklos Magyari's avatar
Miklos Magyari committed
224
// function with class parameter 
225
226
227
function f_class_param(FuncClass pl_fun) {
	var integer vl_int := pl_fun.f_dummy(1);		// type mismatch
	var charstring vl_chr := pl_fun.f_get_one();	// correct
228
229
}

230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
// class function with `runs on`, `mtc` and `system` clause
type class BadClauses {
	public function f_with_runson() runs on CT {
	  
	}
	
	public function f_with_mtc() mtc CT return integer {
		return 1;
	}
	
	public function f_with_system() system CT {
	  
	}
	
	public function f_with_more() runs on CT mtc CT system CT {
	  
	}
}

249
250
251
252
253
254
255
256
257
testcase tc_basicSyntax() runs on CT {
	var GrandSubClass vl_gsc := GrandSubClass.create;
	
	var integer vl_int1 := vl_gsc.vl_c;		// correct : own class member
	var integer vl_int2 := vl_gsc.vl_b;		// correct : inherited from direct parent
	var integer vl_int3 := vl_gsc.vl_a;		// correct : inherited from upper parent
	
	var charstring vl_int4 := vl_gsc.vl_d;		// incorrect : nonexisting member
	var charstring vl_int5 := vl_gsc.vl_a;		// incorrect : type mismatch
258
259
260
261
262
263
264
265
266
	
	var OuterClass vl_outer := OuterClass.create;
	var OuterClass vl_outer2;
	if (vl_outer of OuterClass) {			
		vl_outer := vl_outer2;
	}
	
	var integer vl_integer := vl_outer of OuterClass;			// type mismatch
	var boolean vl_boolean := vl_outer of BaseFunctionClass;	// semanticall correct
267
268
269
	
	// nested class member reference
	var octetstring vl_octet := vl_outer.NestedClass.InnerClass.EvenDeeper.Core.f_inside(1)
270
271
}

272
}