releasenotes.adoc 308 KB
Newer Older
Elemer Lelik's avatar
Elemer Lelik committed
1
2
---
Author: Elemér Lelik
Elemer Lelik's avatar
Elemer Lelik committed
3
4
Version: 109 47-CRL 113 200/6 Uen, Rev. E
Date: 2018-11-04
Elemer Lelik's avatar
Elemer Lelik committed
5
6
7
8
9
10
11

---
= Release Notes for TITAN TTCN-3 Test Executor
:author: Elemér Lelik
:revnumber: 109 47-CRL 113 200/6 Uen, Rev. D
:revdate: 2018-05-24
:title-logo-image: images/titan_logo.png
12
13
14
:sectnums:
:doctype: book
:leveloffset: +1
Elemer Lelik's avatar
Elemer Lelik committed
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
:toc:

ifdef::env-github,backend-html5[]
image::images/titan_logo.png[alt]
endif::[]

= Introduction

This document describes changes implemented in TITAN TTCN–3 toolset and the associated Test Port API from the initial TITAN TTCN–3 release through to the current release.

The document is organized as follows: <<what-s-new-in-this-version,What's new in this version?>> gives a short overview about the new features of major releases. <<version-history,Version history>> contains the detailed list of changes, including new functionalities and solved problems, throughout the history of TITAN TTCN–3 toolset. <<Changes-of-Test-Port-API,Changes of Test Port API>> summarizes the changes of the Test Port API in each version.

[[what-s-new-in-this-version]]
= What’s new in this version?

Elemer Lelik's avatar
Elemer Lelik committed
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
[[version-6-5-crl-113-200-6-r5a]]
== Version 6.5 (CRL 113 200/6 R5A)

This release introduces real-time support according to 
TTCN-3 Language Extensions:
TTCN-3 Performance and Real Time Testing  
as a major new feature. 

This version has the following new features:

* License upgrade to EPL 2.0
* Documentation migrated to asciidoc
* Bugfixes for core, ASN.1, XML, RAW, OER  codecs, XSD2TTCN 
* New RAW coding instruction 'FORCEOMIT'
* New JSON attribute 'as map'
* Attribute 'text ... as ...' for JSON
* Adopt Makefilegen for the Debian packaging
* Support for real-time testing in TITAN
Added compiler option '-I', which enables the real-time testing features mentioned here. 
The features are disabled by default, and the new keywords ('now', 'realtime' and 'timestamp') 
can be used as identifiers again (for backward compatibility).

Also added makefilegen option '-i', which activates this option for the compiler, 
and the makefile setting 'enableRealtimeTesting' in the TPD, which does the same thing.

* New flag for xsd2ttcn
-o:             generate all definitions into one module (called XSD_Definitions)

Elemer Lelik's avatar
Elemer Lelik committed
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
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
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
[[version-6-4-crl-113-200-6-r4a]]
== Version 6.4 (CRL 113 200/6 R4A)

This release is mainly a corrective release, it introduces no major new features. No backward incompatibilities are to be expected, with maybe one exception we see as a minor risk: the fix for Bug 533767 - RAW encoder ALIGN(right) is working according of specification of ALIGN(left) (and vice versa) for octetstring may induce under some unlikely circumstances an incompatible behavior.

This version has the following new features:

* Implement verdict redirect for 'done' statement
* `str2float` should handle special float values
* RT2 record equality
* `string2ttcn` to filter patterns of visible characters in octetstrings
* Syntax to bind a variant attribute to multiple encodings
* TITAN build on Alpine Linux
* new tpd tag `disableUserInformation`
* runs on scope reduction (Titanium)
* Add discarding option to `setstate` operation
* Notify user if port is not mapped in translation mode
* Implement reference to port in translation function
* Implement extendable sequence coding in OER
* TAG and CROSSTAG for JSON encoder

[[version-6-3-crl-113-200-6-r3a]]
== Version 6.3 (CRL 113 200/6 R3A)

This version has the following new features:

* new compiler options:
** e: enforce legacy handling of `encode` and `variant` attributes
** O: disable OER encoder/decoder functions
** D: disable user and time information generation in the generated files
* Support for multiple encodings
* Implement OER coder in TITAN (with the option to restrict generation of OER codecs)
* Implement OER negative testing
* Allowing to start functions with `out` and `inout` formal parameters
* Enable 'out' parameters for behavior functions in the 'start' operation support for dynamic erroneous attributes
* Allow translation ports to work as internal ports
* Allow sending and receiving during translation functions
* Flag to disable time and user information in the generated files
* Implement mtc and system clauses in `testcase` and `altstep` and functions
* Add runtime configuration setting for plain XML and JSON encodings
* Implement `json2cbor` and `cbor2json`
* Implement `json2bson` and `bson2json`
* JSON enc/dec: encoding enumerated values in number form
* Support `enableLegacyEncoding` in tpd
* Add the encoding legacy switch to tpd TEXT codec
* Add the encoding legacy switch to makefilegen
* Add support for NULL terminated string in RAW
* RAW: add offset option to `LENGTHTO` attribute
* RAW: Support also `… bits` syntax in variant attributes

[[version-6-2-crl-113-200-6-r2a]]
== Version 6.2 (CRL 113 200/6 R2A)

This version has the following new features:

* new compiler options:
** J: Compiler (and xsd2ttcn, makefilegen) option to read input files list from a text file
** N: ignore UNTAGGED encoding instruction on top level unions (legacy behavior)
* support of encvalue/decvalue for ASN.1 types
* support for implicit call of PER codec external functions
* implemented: ports with translation capability
* support for concatenation of templates
* implemented any from clause and index redirects with the use of the @index modifier (see standard, chapters 21-23)
* support for dynamic erroneous attributes
* implemented @fuzzy support
* support for external functions for decmatch and @decoded
* no support of Solaris binaries from this release of Titan (older versions of course will continue to support Solaris)
* makefilegen more restrictive on name attribute of the referenced project
* makefilegen: remove generated headers dependency from all `.c` `.cc` files
* (This will revert the following bugs: Bug 499963 - The generated `Makefile` does not make full build when `-j` switch is present ; Bug 512688 - makefilegen: Incorrect `.c` and `.cc` compiling rule )
* XER: allow `anytype` to be xer enc/decodable
* JSON `as value` attribute extended for records/sets with one field and for the `anytype`
* *make archive* button in Eclipse
* support for `make port` command in Eclipse
* plug-ins upgraded to Jung 2.1 +

This list is not comprehensive; for details, see document embedded in PRI.

[[version-6-1-crl-113-200-6-r1a]]
== Version 6.1 (CRL 113 200/6 R1A)

This version has the following new features:

* support for `mctr reconf` command
* command line debugger
* advanced code splitting
* makefilegen capability to handle .xsd files
* makefilegen and compiler to handle file lists in files(`compiler –J` file or `makefilegen –J` file)
* new compiler switch for decreasing variant errorlevel from error to warning
* LTTng logger plug-in
* encvalue/decvalue for ASN.1 types
* Titan build for ARM/Raspberry Pi
* decmatch and @decoded
* istemplatekind
* select union
* @nocase
* Partial @deterministic support
* Storing parts of received messages

Incompatibilities:

* warning changed to error when '*' is used for mandatory elements
* infinity/NaN not allowed at timer start
* receive handling changed (receive(*) and receive(?) not allowed or restricted) +

The above is not a comprehensive list; for all details , pls. check the document embedded in PRI.

[[version-5-5-crl-113-200-5-r5a]]
== Version 5.5 (CRL 113 200/5 R5A)

This version has the following new features:

* type substitutionGroup support
* allow using specific encode attribute strings to identify encode functions
* `ttcn2json`: extra keyword for restricted "as value" unions
* makefilegen shall generate `-Y` if tpd orders it
* user Debug classes
* negative testing with JSON encoder
* new compiler switch for decreasing variant errorlevel from error to warning
* makefilegen supports commenting out `OPENSSL_DIR` based on tpd setting
* activate emergency logging when a test fails
* `makefilegen -I` option
* RAW encoder for universal character string
* ISO 10646-conformant unicode syntaxes
* new internal functions: `encvalue2unichar`/`decvalue2unichar`,`any2unistr`
* `make port` command
* `checkstate port` operation
* clang support in Titan
* Eclipse Designer: implement fast algorithm
* config parser/editor based on ANTLR 4
* A number of TRs related to XML, Eclipse, JSON
* negative and positive conformance tests covering core language part of the standard added
* new document: statement of compliance covering Core language part of the standard
* legacy switches:
** M: allow 'omit' in template value lists (legacy behavior) (artf692717)
** B: allow selected union field to be unbound (legacy behavior) (artf717563)

[[version-5-4-crl-113-200-5-r4a]]
== Version 5.4 (CRL 113 200/5 R4A)

This version has the following new features:

* Refactored xsd2ttcn converter
* Eclipse plug-ins migrated from ANTLR 2 to ANTLR 4.
* 60 Eclipse plug-in related TRs and CRs implemented.
* Function calls with subreferences (artf550360)
* Template(present) accepts complement matching (artf564824)
* Integer to enumerated (artf590888)
* Support for IntX in RAW(artf607782)
* Module parameters can be initialized with module parameters (artf618367)
* Improved logformat to pretty-print XML and JSON

[[version-5-3-crl-113-200-5-r3a]]
== Version 5.3 (CRL 113 200/5 R3A)

This version has the following new features:

* TEXT codec to support universal character string (UTF-8).
* New Junit Logger plugin with extended logging.
* First version of the coverage/profiler tool.
* Stack trace displayed in case of segmentation fault or abort().
* Allow component and default types in module parameters.

[[version-5-2-crl-113-200-5-r2a]]
== Version 5.2 (CRL 113 200/5 R2A)

This version has the following new features:

* `Makefilegen –Z` option: Faster than the previous recursive linking method , support for dynamic linking, improved make archive
* `Makefilegen –H` option: support for partial build of hierarchical *.tpd structures.
* `Ttcn2json` improved ASN.1 handling, including parameterized types
* TR HS 34398 revoked.
* As the solution to TR HT 24380 caused performance problems, this was removed from RT1 (the default load test runtime)

[[version-5-1-crl-113-200-5-r1a]]
== Version 5.1 (CRL 113 200/5 R1A)

This version has the following new features:

* Changes in the assignment of charstring and universal charstring values to permit direct assignment of Unicode characters in editors with UTF-8 support.
* *Out parameter behavior changed: all out parameters are set to <unbound> at the start of the function. As this could cause incompatible behavior, a compiler option enforcing legacy behavior (`-Y`) was introduced.*
* A number of deprecated compiler options (`-E`, `-n`, `-N`, `-B`) were removed.
* New JSON codec variants "as value", "default".
* TTCN-3 type to JSON schema converter compiler option introduced.
* Eclipse plug-in improvements.
* Macro redefinition functionality for TITAN TTCN-3 Test Executor in the `[DEFINE]` section of the .cfg file.
* Nested concatenation operator `&`= in the `[MODULE_PARAMETERS]` section of the .cfg file
* Eclipse plug-in package and bundle id’s (including extension point id’s) have been changed due to open sourcing Titan. Their names start with *"org.eclipse.titan"* instead of *"com.ericsson.titan"*
* Legacy `mctr_gui` and `logbrowser` (based on Qt3 which lacks support in modern Linux versions) removed. The last version can still be obtained from older Titan packages.
* `Ctags` support removed due to licensing problems (`ctags` files can be obtained from older Titan releases).
* From this release, usage of 64-bit Cygwin is encouraged. A 32 bit version will not be released.
* Correction for newer openssl packages that break Titan license validation.

IMPORTANT: Titan releases previous to CRL 113 200/5 R1A will not work if openssl is upgraded beyond the critical level of release; the exact level depends on the Linux platform and version.

* *A correction for TR HT24380 (Error in manipulating dependent inout parameters - a record of and its element) may cause incompatible behavior (see TR for further details). When Titans’ behavior might change compared to previous releases, a warning message- intended to help users to detect sequences of TTCN-3 code that need to be changed- will be displayed.*

[[version-4-2-crl-113-200-4-r2a]]
== Version 4.2 (CRL 113 200/4 R2A)

This version has the following new features:

* JSON encoding support.
* Support for various universal character string encodings (UTF-8, UTF-16LE, UTF-16BE, UTF-32LE, UTF-32BE).
* Built-in support for base64 encodings.
* Java executor API for Titan.
* Eclipse plug-in improvements.
* Configurable timestamp in console.
* Improved behavior in port congestion situations.
* Superfluous circular warnings for ASN.1 disabled.
* TEXT encoder debug logging.
* Several improvements regarding the XML encoding/decoding.
* T3Doc disabled in the Designer.
* The asciiart directory emptied to prevent interference with automated usage.

Important notes:

* As the referenced TTCN-3 standards for universal character string encodings and for JSON are not finalized yet, details of these (as in exact function names) may change.
* The following new keywords have been introduced in this release: `oct2unichar`, `unichar2oct`, `get_stringencoding`, `remove_bom`, `encode_base64`, `decode_base64`

[[version-4-1-crl-113-200-4-r1a]]
== Version 4.1 (CRL 113 200/4 R1A)

This version has the following new features:

* Catching Dynamic Test case errors – Adds the ability to survive DTEs in TTCN-3 code, for instance in case of long running load tests. Very similar to exception handling used in other languages.
* Lazy Parameter Evaluation – In formal parameters can be defined to be subject of lazy evaluation: the expression used as actual parameter shall be evaluated only when the formal parameter is used (not at the function call); the evaluation is only done once.
* Titanium – new Eclipse plugin, a code quality analysis prototype for advanced users, available upon request.
* Usage statistics - Titan compiler, runtime and Titan Eclipse plug-in usages are collected for statistical purposes.
* Change of default error behavior for XML encoding from 'Warning' to 'Error' to align with the other Titan encoders.
* Template Module Parameters - TTCN-3 language extension, module parameters can be both values (standard) and templates (non-standard).
* `Ttcn2string()` predefined function - returns the parameter’s value in TTCN-3 string representation. `String2ttcn()` predefined function - `Ttcn2string()` predefined function contrariwise.

NOTE: Please make sure that your makefile contains the following part marked with red:

[source, subs="+quotes"]
----
SOLARIS8_LIBS =[red]#*-lresolv -lnsl -lsocket*#

LINUX_LIBS = [red]#*-lpthread -lrt*#
----
[[version-3-2]]
== Version 3.2

This version has the following new features:

* Support for distributed build using hierarchical `Makefiles` with new `ttcn3_makefilegen` command line options (`-r`, `-F`).
* New makefile target "library" is implemented. The pre-compiled objects can be collected to a library archive file(.a or .so), useful when the project hierarchy has rarely changing parts.
* Extended _.tpd file handling in makefilegen was introduced. `ttcn3_makefilegen` processes the `MakefileSettings` part of the _.tpd files. Benefits: *.tpd files extracted/created with Eclipse can be used in command line and usage of makefilepatch scripts can be hugely reduced or even eliminated.
* `ORDERED_INCLUDE` in configuration files is implemented; the includes will be strictly ordered.
* Clean-up after unsuccessful makefilegen execution, `symlinks` are now generated only if no errors were found during *.tpd file processing
* _.tpd file validation with `ttcn3_makefilegen`: the _.tpd file is validated with a schema that now is part of TITAN (`file $(TTCN3_DIR)/etc/xsd/TPD.xsd` ); validation errors will prevent makefile generation.
* `Makefilegen`: override the working directory in _.tpd file: the working directory of top level project comes from top level _.tpd file by default; when using the –D switch the working directory will be the current directory.
* `Makefilegen` support for OSS Nokalva ASN.1 compiler is implemented. `Makefile` generation from *.tpd file enables OSS Nokalva support without custom makefilepatch scripts
* Integration of DPMG(Diameter Protocol Module Generator) into the TITAN build system.
* Improved *.tpd file related documentation.
* Reduced nr of supported gcc versions. Supported versions are: 3.4.6 – 4.7.2
* Changes in supported platforms: Solaris versions from 5.10 are supported; Cygwin versions from 1.7 are supported. Earlier Solaris and Cygwin versions are not supported
* Titan Eclipse plugins support Eclipse versions from Eclipse 3.7.2 to Eclipse 4.2
* Java 1.6 is the minimum requirement
* A fourth Eclipse plug-in, Titanium, is released as a prototype. Update and maintenance of Titanium will be the responsibility of the Titanium project until further notice. For details pls. see https://ericoll2.internal.ericsson.com/sites/DUCI_SW_Technology/Titanium/default.aspx

[[version-3-1]]
== Version 3.1

Version 3.1 has the following new features:

* Interface implemented for the TestStatistics tool
* All from in value list, subset, superset and permutation supported
* Embedded macro references in the `[DEFINE]` section - runtime (support in command line)
* Structured macro definitions in the `[DEFINE]` section - runtime (support in command line)
* Embedding TTCN-3 functions (limited functionality)

[[version-2-2]]
== Version 2.2

Version 2.2 has the following new features:

* XML encoding is now supported for the hexstring and verdicttype TTCN-3 types

* Transparent functions were introduced to allow easier identification of failing tests in case of SourceInfo := Single.

[[version-2-1]]
== Version 2.1

Version 2.1 has the following new features:

* The Titan Eclipse Designer’s support for preprocessed TTCN-3 files has been improved.
* The performance of TEXT decoding has been improved.
* A logger plugin (JUnitLogger) is now delivered with Titan. It outputs XML files in the same format as JUnit. Using this logger plugin allows integrating of Titan with the Jenkins (Hudson) continuous integration tool.
* To allow JUnitLogger to receive the necessary information, the Titan Logger API has been slightly changed. Existing logger plugins will need to be rebuilt.
349
* In response to a TR (HP88760), the {cpp} interface of the OBJID class has been changed. The type of the elements in the internal storage of the OBJID class is now specified with a `typedef`, `objid_component`. Code which uses the indexing operators or directly accesses the element storage will need to be rewritten. It is a backward incompatible change and it affects users of the SNMP test port. A new version of the SNMP test port was released (CNL 113 344 R4B) compatible with the new Titan.
Elemer Lelik's avatar
Elemer Lelik committed
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
* `ttcn3_makefilegen` has a new flag `–P`, which prints out the list of files found in a given TPD recursively relative to a given directory.
* TTCN-3 level code coverage was implemented.
* Text hover for T3Doc in Eclipse was implemented.
* `mctr_gui`, `ttcn3_logbrowser`, `ctags`, Nedit, XEmacs support is part of the Titan package again.

[[version-1-10]]
== Version 1.10

Version 1.10 has the following new features:

* Renaming refactoring was implemented in Titan Eclipse Designer. This feature provides TTCN-3 scope-aware renaming of declarations.
* Selection highlighting was implemented in Titan Eclipse Designer. When a variable name or function name or keyword is selected in the code, all the occurrences of the selected variable name or function name or keyword will be highlighted in the same file.
* Performance of `log2str()` was improved.
* Implicit omit support for module parameters was implemented.
* Append operation (`&=`) for list types in configuration files was implemented.
* Support of executing testcases with default parameters from command line and configuration file was added.
* Improved error recovery for the compiler. E.g. it can now stop on the first syntactic error and skip the semantic analysis.

[[version-1-9]]
== Version 1.9

Version 1.9 has the following new features:

* With the release we have decided to change from the proprietary Titan versioning scheme, to the one used by Ericsson. From now on it will be much easier to decide if a new version is forward, backward compatible with a previous version. The versioning is also supported in the attributes of the modules, with some limitations. We only accept version numbers in 3 formats: R9A, CRL 113 200 R9A and CRL 113 200/1 R9A.

* With this release we removed all QT based GUI parts (`mctr_gui`) and `ctags` from the official Titan releases, as they have been in maintenance phase for the last year. NEdit and XEmacs parts are still available as downloadable components from our download pages.

* The import of imports feature declared in the newest TTCN-3 standard was implemented. This way it is now possible to recursively import import statements from other modules.

* IPv6 support for Titan’s internal communication was implemented. This way Titan is now able to function properly when the MC and PTCs are located on an IPv6 network.

* The makefilegen tool in the command line package is now able to generate `Makefiles` from the information stored in .Tpd project descriptor files.

* It is now possible to find all reference pointing to a given declaration inside eclipse. Finding all references to a definition was implemented as a new kind of search in the Eclipse platform.

* The Executor plug-in will now be able to automatically merge the generated log files after execution.

[[version-1-8]]
== Version 1.8

Version 1.8 has the following new features:

* The `testcase.stop` operation is now supported, allowing for the users to stop the execution of the actual `testcase` raising a dynamic `testcase` error with a custom explanation text.

* The `ispresent` predefined function was extended to operate on all structured types and fields as described in the 4.3.2 version of the TTCN-3 standard.

* The main features of the LogViewer eclipse feature can no be accessed from the Project Explorer too, so it is no longer required to switch to its custom navigator.

* It is now possible to configure the Executor feature and eclipse executed "launch configurations" to automatically merge the log files that were generated during execution. For the case of several consecutive executions it is now possible to configure the system, to remove the previous log files before a new execution.

* Added the negative testing feature allowing to generate invalid messages, and to send them to the SUT, to observe its reaction.
* With the help of emergency logging it is now possible to define different behaviors for logging in normal and in emergency situations.
* The performance of the LogViewer plug-in has been enhanced considerably, to support the processing of arbitrary large log files.
* Titan is no longer depending on the external Readline package. It has been replaced with Editline, which is now compiled into the delivered packages.
* A new project description format has been created to support exporting and importing the data of Titan projects in eclipse into a single file.
* The LogViewer eclipse plug-in was enhanced to work on larger files, with less resource consumption. Also it is now much better integrated with the rest of the toolset.

* Huge increase in the speed of the on-the-fly analysis in the Designer plug-in, with much more efficient memory usage when the incremental parsing option is turned on.

* The Designer now supports build configurations allowing switching between sets of build settings in a consistent way.

* The build action of Eclipse can now be invoked from the command line on two ways. One guaranteeing to build exactly as Eclipse is doing it, and one allowing the user to fine tune all of his settings.

* Support for the launch shortcut feature of eclipse was introduced allowing to create and initialize new launch configurations in an easier way.

* The base of the TTCN-3 standard used to describe the features and limitations of TITAN was changed from version v3.1.1 to v4.1.1

* The build process was enhanced with options for dynamic linking, advanced dependency refreshing, and with splitting the generated code into several files.

* The checking of subtypes in TTCN-3 and ASN.1 modules was enhanced considerably, and the on-the-fly semantic analyzer in the Designer plug-in was brought on the same level as the command line compiler is on.

* Introduced support for the module interface feature, allowing for the user to hide internal parts of a module from the other modules.

* Introduced the `testcasename()` and removed the `sizeoftype()` predefined function in accordance with the standard.

* Support for XML encoding and decoding is introduced, together with a new command line tool that converts XSD files into TTCN-3 modules.

* The `enum2int`, `encode` and `decode` predefined functions were introduced.

* It is now possible to use the `concatenation`, `replace`, `substr`, `lengthof` predefined functions on values of the set of, record of an array types.

* The implicit omit attribute is now supported.

* The TTCN-3 type anytype became supported with some restrictions.

* The runtime was split into two versions: one for function testing where much less code is generated, at the cost of somewhat degraded runtime performance; and one for load testing. Both are compatible with the interfaces of the original runtime.

* Both eclipse plug-ins were enhanced to be able to format and merge log files produced by an execution.

* The on-the-fly semantic analyzer of the Designer plug-in was considerably enhanced.

* The code quality checks done by the on-the-fly in the designer plug-in were extended to detect unused local and module level definitions too.

* The checking of the validity of the license file was introduced in the Designer plug-in, so as to protect it from unauthorized usage.

* The Designer plug-in was enhanced to be able to parse TTCN-3 files in an incremental manner, which should reduce the time required for analyzing a project from a few second, to a few times 10-2 seconds.

* The designer plug-in was extended with its own internal Makefile generator.

[[version-1-7]]
== Version 1.7

Version 1.7 has the following new features:

454
* The naming convention of the generated {cpp} code has been revised to avoid potential name clashes between definitions. The definitions of each TTCN–3 and ASN.1 module is put into a separate {cpp} namespace that corresponds to the module name. This eliminates all problems caused by definitions with identical names in different modules. The scope of {cpp} enum values that represent the values of TTCN–3 and ASN.1 enumerated types became narrower to avoid conflicts if the same element name appears in two different enumerated types.
Elemer Lelik's avatar
Elemer Lelik committed
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480

* Extension (inheritance) of TTCN–3 component types and compatibility between different component types is now supported by the compiler.

* Dual-faced TTCN–3 ports, which can transform the incoming and outgoing messages, were introduced. Using this feature the compiler is capable of automatic generation of TTCN–3 external functions that perform encoding or decoding based on the built-in codecs (RAW, BER, TEXT).

* The Runtime GUI has become a stand-alone product. It is no longer part of the TTCN–3 Executor package.

* The logging functionality has been significantly enhanced. From now the types of events logged can be set using much finer granularity. Using the name of the component in the name of the log files also became possible.

* From now it is possible to assign actual parameters in a parameter list to a specific formal parameter from the formal parameters of the type.

* It is now possible to use assignment notation with array indices.

* The efficiency of connection handling of the Main Controller, the Parallel Test Components and the testports was greatly enhanced.

* The Eclipse Designer plug-in is now building an AST that is structurally equivalent to the on found in the compiler, and stores about the same amount of data. Thus increasing the amount of semantic errors that can be detected on-the-fly without invoking the build system.

* The logging of the `match` operation was made configurable through the `MatchingHints` logging option. If it is set in "Compact" mode (which is the default) the log record will be only a few lines long, instead of a few hundred lines long. In fact if there is only one field mismatching than the log will contain 1 line regardless of the size and structure of the value and template compared.

[[version-1-6]]
== Version 1.6

Version 1.6 has the following new features:

* The semantic check for the TTCN–3 dynamic behavior descriptions (such as functions, altsteps, testcases) have been implemented, which means that all parts of TTCN–3 modules are now analyzed.

481
* The compiler generates the entire {cpp} code from the Abstract Syntax Tree, that is, the output of semantic analysis. This makes it possible to add support for some language constructs and perform code optimization in future versions. These were impossible with the old, parser-based code generator.
Elemer Lelik's avatar
Elemer Lelik committed
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513

* The TTCN–3 parser of the compiler supports recovery from syntax errors. This means the compiler does not stop when a syntax error is detected, but it continues to analyze the input to find more errors. +

NOTE: In some cases it is not possible or worthwhile to recover from a syntax errorfootnote:[For example, the parser may get confused after a missing opening or closing bracket and ignore the rest of input module.].

* Code generation for in-line compound values and templates (including in-line modified templates) is now supported.

* The initializer sequences of constants and non-parameterized templates are ordered automatically so that forward references do not cause dynamic test case errors anymore.

* Support of TTCN–3 language constructs has been enhanced. There is full support of arrays, groups and attributes. Select-case and interleave statements as well as alive PTCs were implemented.

* Text encoding has been introduced.

* Function, altstep and testcase references are supported in TTCN–3 .

* Non-mandatory parameters (i.e. default values for formal parameters) are supported in TTCN–3 .

* Usage of C preprocessor on TTCN–3 modules is allowed.

* The Makefile generator has been significantly enhanced and moved from the compiler to a stand-alone program.

* The syntax of run-time configuration files has been enhanced to allow the use of macros and environment variables. Modularity (i.e. spreading configuration data over several files) is also supported.

[[version-1-5]]
== Version 1.5

Version 1.5 has the following new features:

* The compiler supports the semantic analysis for all TTCN–3 definitions except the dynamic parts (i.e. functions, altsteps, testcases and control parts). This means that new checking routines were implemented for TTCN–3 subtype constraints, signatures, constants, templates and all definitions within component types.

* The compiler produces user-friendly error messages with file name and line number information and supports error recovery. It displays all error messages found in the input modules.

514
* The time needed for the compilation of generated {cpp} code was significantly reduced compared to 1.4.pl0. The saving can be more than 50 % in case of large projects.
Elemer Lelik's avatar
Elemer Lelik committed
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532

* Procedure based TTCN–3 ports and the related communication operations are now supported with enhanced Test Port API.

* The run-time environment provides one unified API for both RAW and BER encoder/decoder functions.

* The internal structure of RAW encoder/decoder functions was significantly revised. This results in faster and more robust operation.

[[version-1-4]]
== Version 1.4

Version 1.4 has the following new features:

* One integrated compiler for TTCN–3 and ASN.1. This allows the semantic analysis of test suites that import from ASN.1 modules without intermediate files. The command line switches of the previous two compilers were unified.

* The ASN.1 front-end of the compiler was significantly enhanced to handle X.681- X.683 extensions.

* The compiler supports the full semantic analysis of ASN.1 modules and semantic analysis of TTCN–3 type definitions. The output for other TTCN–3 definitions is still generated on the fly without checks.

533
* The compiler performs automatic reordering in the generated code for TTCN–3 types as well. This means, the generated {cpp} code will be always valid even if the type definitions use forward referencing. +
Elemer Lelik's avatar
Elemer Lelik committed
534

535
NOTE: The forward referencing problem between TTCN–3 constants and templates is still unsolved. They must be declared in bottom-up order to get a working {cpp} code.
Elemer Lelik's avatar
Elemer Lelik committed
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574

* The code generation routines of the previous compilers were fully re-used and no significant changes were made in the Base Library in order to preserve the stability of the executable tests.

[[version-1-3]]
== Version 1.3

Version 1.3 has the following new features:

The Main Controller was completely re-designed in this version, which means the following advantages:

* There are no longer static limits on the number of simultaneously active PTCs.

* Improved and more comfortable command-line interface (with history, command completion, etc.).

* More robust and more efficient handling of large number of test components and/or port connections. Graceful recovery from run-time errors.

* Central configuration file handling and automatic distribution of configuration parameters.

* Version checking in MC to avoid inconsistent ETSes in distributed test environments.

* Faster execution of TTCN–3 configuration operations.

* Explicit control of PTC locations with user-defined constraints in addition to load balancing.

* A lot of Main Controller related bugs were fixed, which caused deadlocks in some situations before.

* TTCN–3 address type is supported by the compiler and the Test Port API.

* Lot of bug fixes in the compilers and the run-time environment.

* Re-organized chapters and clarifications in the user documentation.

[[version-1-2]]
== Version 1.2

Version 1.2 has the following new features:

* The compiler supports the new, Edition 2 syntax of the TTCN–3 Core Language. The obsolete language elements that were supported in version 1.1 (e.g. named alternatives) are still accepted for backward compatibility, but a warning message is printed.

575
* The toolset contains a new ASN.1 compiler, which allows the importing of ASN.1 modules into TTCN–3 test suites. Like the TTCN–3 compiler, the ASN.1 compiler translates ASN.1 definitions to {cpp} code, which shall be used together with {cpp} output of TTCN–3 modules.
Elemer Lelik's avatar
Elemer Lelik committed
576

577
* The ASN.1 compiler performs a semantic analysis on its input and reports errors instead of generating invalid {cpp} code.
Elemer Lelik's avatar
Elemer Lelik committed
578

579
* The ASN.1 compiler may generate additional functions for the equivalent {cpp} classes of ASN.1 data types that allow the encoding and decoding of data values according to the Basic Encoding Rules (BER) of ASN.1.
Elemer Lelik's avatar
Elemer Lelik committed
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932

* The TTCN–3 compiler has a new feature that may generate additional functions for TTCN–3 data types for direct (RAW) encoding/decoding of messages. This encoding scheme can be efficiently used for protocols that define the encoding of its PDUs in table-based format. The encoding rules shall be specified in special with attributes of the data types.

* The TTCN–3 compiler and runtime environment provides full support for the use of altsteps and dynamic defaults as specified in the (link:https://www.etsi.org/deliver/etsi_es/201800_201899/20187301/04.01.01_60/es_20187301v040101p.pdf[Edition 2 of TTCN–3 standard]). Moreover, for backward compatibility, the obsolete named alts can also be used, even in combination with altsteps and defaults.

* The internal handling of TTCN–3 string types (bitstring, octetstring, charstring) has been improved. The runtime environment can copy string values without memory allocation, which may result in 50% performance improvement in some cases. The Test Port API for these types did not change.

* We have a comprehensive regression test suite for the tool itself. It covers almost all basic and user-defined types, built-in operators, template and behavior constructs of the TTCN–3 language. The tests are run before each release to minimize the remaining bugs.

* Lots of minor improvements and bug fixes.

* The tool is no longer called prototype. Quick help to achieve full backward compatibility with version 1.1. For the meaning of these switches please refer to the respective sections of this document.

* Use the `-u` and `-r` flags for the TTCN–3 compiler.

* Use the `-s` flag for the logformat utility.

* Ignore all warnings of the compiler that refer to obsolete TTCN–3 language elements.

[[version-1-1]]
== Version 1.1

Version 1.1 has the following new features:

* Support of parallel test execution. Full support of TTCN–3 create, start, stop, running and done operations.

* Support of distributed test execution, which means scalability. Automatic load balancing between the participating computers.

* Platform interoperability, that is, test components running on any of supported platforms can communicate with each other.

* The total number of parallel test components can be safely increased up to 1000, which enables performance (load) testing with the Test Executor.

* Internal communication between TTCN–3 test components is supported in a transparent way. TTCN–3 `connect`, `disconnect`, `map`, `unmap`, `send (…) to` and `receive (…) from` operations are also fully supported.

* Extended Test Port interface.

* Enhanced command line syntax and functionality of the compiler.

* Many bug fixes.

* Improved User Documentation. For more details, please see the next chapters.

[[version-history]]
= Version history

[[version-crl-113-200-6-r4a]]
== Version CRL 113 200/6 R4A

Release date: 31st of May 2018

*New features:*

* Implement verdict redirect for `done' statement
* str2float should handle special float values
* RT2 record equality
* string2ttcn to filter patterns of visible characters in octetstrings
* Syntax to bind a variant attribute to multiple encodings
* TITAN build on Alpine Linux
* new tpd tag `disableUserInformation`
* runs on scope reduction (Titanium)
* Add discarding option to `setstate` operation
* Notify user if port is not mapped in translation mode
* Implement reference to port in translation function
* Implement extendable sequence coding in OER
* TAG and CROSSTAG for JSON encoder

[[version-crl-113-200-6-r3a]]
== Version CRL 113 200/6 R3A

Release date: 17th of November, 2017

*New features:*

* new compiler options:
** -e: enforce legacy handling of `encode` and `variant` attributes
** -O: disable OER encoder/decoder functions
** -D: disable user and time information generation in the generated files
* Support for multiple encodings
* Implement OER coder in TITAN (with the option to restrict generation of OER codecs)
* Implement OER negative testing
* Allowing to start functions with `out` and `inout` formal parameters
* Enable `out` parameters for behavior functions in the `start` operation support for dynamic erroneous attributes
* Allow translation ports to work as internal ports
* Allow sending and receiving during translation functions
* Flag to disable time and user information in the generated files
* Implement mtc and system clauses in testcase and altstep and functions
* Add runtime configuration setting for plain XML and JSON encodings
* Implement `json2cbor` and `cbor2json`
* Implement `json2bson` and `bson2json`
* JSON enc/dec: encoding enumerated values in number form
* Support `enableLegacyEncoding` in tpd
* Add the encoding legacy switch to tpd TEXT codec
* Add the encoding legacy switch to makefilegen
* Add support for NULL terminated string in RAW
* RAW: add offset option to `LENGTHTO` attribute
* RAW: Support also `… bits` syntax in variant attributes

[[version-crl-113-200-6-r2a]]
== Version CRL 113 200/6 R2A

Release date: 26th of May, 2017

*New features:*

* new compiler options:

`-J`: Compiler (and `xsd2ttcn`, makefilegen) option to read input files list from a text file

`-N`: ignore UNTAGGED encoding instruction on top level unions (legacy behavior)

* support of encvalue/decvalue for ASN.1 types
* support for implicit call of PER codec external functions
* implemented: ports with translation capability
* support for concatenation of templates
* implemented 'any from' clause and index redirects with the use of the @index modifier (see standard, chapters 21-23)
* support for dynamic erroneous attributes
* implemented @fuzzy support
* support for external functions for decmatch and @decoded
* no support of Solaris binaries from this release of Titan (older versions of course will continue to support Solaris)
* makefilegen more restrictive on name attribute of the referenced project
* makefilegen: remove generated headers dependency from all `.c` `.cc` files

(This will revert the following bugs:Bug 499963 - The generated Makefile does not make full build when `-j` switch is present ; Bug 512688 - makefilegen: Incorrect `.c` and `.cc` compiling rule )

* XER: allow anytype to be xer enc/decodable
* JSON `as value` attribute extended for records/sets with one field and for the anytype
* *make archive* button in Eclipse
* support for `make port` command in Eclipse
* plug-ins upgraded to Jung 2.1

[[version-crl-113-200-6-r1a]]
== Version CRL 113 200/6 R1A

Release date: 18th of November, 2016

*New features:*

* support for `mctr reconf` command
* command line debugger
* advanced code splitting
* makefilegen capability to handle `.xsd` files
* makefilegen and compiler to handle file lists in files(`compiler –J` file or `makefilegen –J` file)
* new compiler switch for decreasing variant errorlevel from error to warning
* LTTng logger plug-in
* encvalue/decvalue for ASN.1 types
* Titan build for ARM/Raspberry Pi
* decmatch and @decoded
* istemplatekind
* select union
* @nocase
* Partial @deterministic support
* Storing parts of received messages

Incompatibilities:

* warning changed to error when '*'is used for mandatory elements
* infinity/NaN not allowed at timer start

receive handling changed (receive(*) and receive(?) not allowed or restricted)

[[version-crl-113-200-5-r5a]]
== Version CRL 113 200/5 R5A

Release date: 26th of May, 2016

*New features:*

* type substitutionGroup support
* allow using specific encode attribute strings to identify encode functions
* `ttcn2json`: extra keyword for restricted "as value" unions
* makefilegen shall generate `-Y` if tpd orders it
* user Debug classes
* negative testing with JSON encoder
* new compiler switch for decreasing variant errorlevel from error to warning
* makefilegen supports commenting out OPENSSL_DIR based on tpd setting
* activate emergency logging when a test fails
* makefilegen `-I` option
* RAW encoder for universal character string
* ISO 10646-conformant unicode syntaxes
* new internal functions: `encvalue2unichar/decvalue2unichar`,`any2unistr`,
* `make port` command
* `checkstate` port operation
* clang support in Titan
* Eclipse Designer: implement fast algorithm
* config parser/editor based on ANTLR 4
* negative and positive conformance tests covering core language part of the standard added
* new document: statement of compliance covering Core language part of the standard
* legacy switches:

-M: allow 'omit' in template value lists (legacy behavior) (artf692717)

-B: allow selected union field to be unbound (legacy behavior) (artf717563)

[[version-crl-113-200-5-r4a]]
== Version CRL 113 200/5 R4A

Release date: 13th of November, 2015

*New features:*

* Refactored xsd2ttcn converter
* Eclipse plug-ins migrated from ANTLR 2 to ANTLR 4.
* 60 Eclipse plug-in related TRs and CRs implemented.
* Function calls with subreferences (artf550360)
* Template(present) accepts complement matching (artf564824)
* Integer to enumerated (artf590888)
* Support for IntX in RAW (artf607782)
* Module parameters can be initialized with module parameters (artf618367)
* Improved logformat to pretty-print XML and JSON

[[version-crl-113-200-5-r3a]]
== Version CRL 113 200/5 R3A

Release date: 22nd of May, 2015

*New features:*

* TEXT codec to support universal character string (UTF-8).
* New Junit Logger plugin with extended logging.
* First version of the coverage/profiler tool.
* Stack trace displayed in case of segmentation fault or `abort()`.
* Allow component and default types in module parameters.

[[version-crl-113-200-5-r2a]]
== Version CRL 113 200/5 R2A

Tentative release date: 19th of March, 2015

*New features:*

* `Makefilegen –Z` option: Faster than the previous recursive linking method , support for dynamic linking, improved make archive
* `Makefilegen –H` option: support for partial build of hierarchical *.tpd structures.
* `Ttcn2json` improved ASN.1 handling, including parameterized types

[[version-crl-113-200-5-r1a]]
== Version CRL 113 200/5 R1A

Tentative release date: 9th of January, 2015

*New features:*

* New JSON codec variants.

* TTCN-3 type to JSON schema converter compiler option introduced.

* Macro redefinition functionality for TITAN TTCN-3 Test Executor in the `[DEFINE]` section of the `.cfg` file.

* Nested concatenation operator `&=` in the `[MODULE_PARAMETERS]` section of the `.cfg` file.

* A number of deprecated compiler options (`-E`, `-n`, `-N`, `-B`) removed.

* Correction for newer openssl packages that break Titan license validation.

IMPORTANT: Titan releases previous to CRL 113 200/5 R1A will not work if openssl is upgraded beyond the critical level of release; the exact level depends on the Linux platform and version.

[[version-crl-113-200-4-r2a]]
== Version CRL 113 200/4 R2A

Released on the 4th of July, 2014

*New features:*

* JSON encoding support.

* Support for various universal character string encodings (UTF-8, UTF-16, UTF-32).

* Built-in support for base64 encodings.

* Java executor API for Titan.

* Eclipse plug-in improvements.

* Configurable timestamp in console.

* Improved behavior in port congestion situations.

* Superfluous circular warnings for ASN.1 disabled.

* TEXT encoder debug logging.

[[version-crl-113-200-4-r1a]]
== Version CRL 113 200/4 R1A

Released on Jan. 10, 2014

*New features:*

* Catching Dynamic Test case errors – Adds the ability to survive DTEs in TTCN-3 code, for instance in case of long running load tests. Very similar to exception handling used in other languages.
* Lazy Parameter Evaluation – In formal parameters can be defined to be subject of lazy evaluation: the expression used as actual parameter shall be evaluated only when the formal parameter is used (not at the function call); the evaluation is only done once.
* Titanium – new Eclipse plugin, a code quality analysis prototype for advanced users, available upon request.
* Usage statistics - Titan compiler, runtime and Titan Eclipse plug-in usages are collected for statistical purposes.
* Change of default error behavior for XML encoding from 'Warning' to 'Error' to align with the other Titan encoders.
* Template Module Parameters - TTCN-3 language extension, module parameters can be both values (standard) and templates (non-standard).
* `Ttcn2string()` predefined function - returns the parameter’s value in TTCN-3 string representation. `String2ttcn()` predefined function - `Ttcn2string()` predefined function contrariwise.

[[version-crl-113-200-3-r2a]]
== Version CRL 113 200/3 R2A

Released on Jul. 5, 2013

*New features:*

* Support for distributed build using hierarchical Makefiles with new `ttcn3_makefilegen` command line options (`-r`, `-F`).
* New makefile target "library" is implemented. The pre-compiled objects can be collected to a library archive file (.a or .so), useful when the project hierarchy has rarely changing parts.
* Extended _.tpd file handling in makefilegen was introduced. `ttcn3_makefilegen` processes the MakefileSettings part of the _.tpd files. Benefits: *.tpd files extracted/created with Eclipse can be used in command line and usage of makefilepatch scripts can be hugely reduced or even eliminated.
* `ORDERED_INCLUDE` in configuration files is implemented; the includes will be strictly ordered.
* Clean-up after unsuccessful makefilegen execution, symlinks are now generated only if no errors were found during *.tpd file processing
* _.tpd file validation with `ttcn3_makefilegen`: the _.tpd file is validated with a schema that now is part of TITAN (file `$(TTCN3_DIR)/etc/xsd/TPD.xsd`); validation errors will prevent makefile generation.
* `Makefilegen`: override the working directory in _.tpd file: the working directory of top level project comes from top level _.tpd file by default; when using the –D switch the working directory will be the current directory.
* `Makefilegen` support for OSS Nokalva ASN.1 compiler is implemented. Makefile generation from *.tpd file enables OSS Nokalva support without custom makefilepatch scripts
* Integration of DPMG (Diameter Protocol Module Generator) into the TITAN build system.
* Improved *.tpd file related documentation.
* Reduced nr of supported gcc versions. Supported versions are: 3.4.6 – 4.7.2
* Changes in supported platforms: Solaris versions from 5.10 are supported; Cygwin versions from 1.7 are supported. Earlier Solaris and Cygwin versions are not supported
* Titan Eclipse plugins support Eclipse versions from Eclipse 3.7.2 to Eclipse 4.2
* Java 1.6 is the minimum requirement
* A fourth Eclipse plug-in, Titanium, is released as a prototype. Update and maintenance of Titanium will be the responsibility of the Titanium project until further notice. For details pls. see https://ericoll2.internal.ericsson.com/sites/DUCI_SW_Technology/Titanium/default.aspx

[[version-crl-113-200-3-r1a]]
== Version CRL 113 200/3 R1A

Released on Jan. 18, 2013

*New features:*

* Interface implemented for the TestStatistics tool
* All from in value list, subset, superset and permutation supported
* Embedded macro references in the `[DEFINE]` section - runtime (support in command line)
* Structured macro definitions in the `[DEFINE]` section - runtime (support in command line)
* Embedding TTCN-3 functions

[[version-crl-113-200-2-r2a]]
== Version CRL 113 200/2 R2A

Released on Aug. 31, 2012

*New features:*

XML encoding is now supported for the hexstring and verdicttype TTCN-3 types

Transparent functions were introduced to allow easier identification of failing tests in case of SourceInfo := Single.

[[version-crl-113-200-2-r1a]]
== Version CRL 113 200/2 R1A

Released on Jun. 27, 2012

*New features:*

* The Titan Eclipse Designer’s support for preprocessed TTCN-3 files has been improved.
* The performance of TEXT decoding has been improved.
* A logger plugin (`JUnitLogger`) is now delivered with Titan. It outputs XML files in the same format as JUnit. Using this logger plugin allows integrating of Titan with the Jenkins (Hudson) continuous integration tool.
* To allow `JUnitLogger` to receive the necessary information, the Titan Logger API has been slightly changed. Existing logger plugins will need to be rebuilt.
933
* In response to a TR (HP88760), the {cpp} interface of the OBJID class has been changed. The type of the elements in the internal storage of the OBJID class is now specified with a `typedef`, `objid_component`. Code which uses the indexing operators or directly accesses the element storage will need to be rewritten. It is a backward incompatible change and it affects users of the SNMP test port. A new version of the SNMP test port was released (CNL 113 344 R4B) compatible with the new Titan.
Elemer Lelik's avatar
Elemer Lelik committed
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
* `ttcn3_makefilegen` has a new flag `–P`, which prints out the list of files found in a given TPD recursively relative to a given directory.
* TTCN-3 level code coverage was implemented.
* Text hover for T3Doc in Eclipse was implemented.
* `mctr_gui`, `ttcn3_logbrowser`, `ctags`, Nedit, XEmacs support is part of the Titan package again.

[[version-crl-113-200-1-r10a]]
== Version CRL 113 200/1 R10A

Released on Apr. 13, 2012

*New features*

* Renaming refactoring was implemented in Titan Eclipse Designer. This feature provides TTCN-3 scope-aware renaming of declarations.
* Selection highlighting was implemented in Titan Eclipse Designer. When a variable name or function name or keyword is selected in the code, all the occurrences of the selected variable name or function name or keyword will be highlighted in the same file.
* Performance of `log2str()` was improved.
* Implicit omit support for module parameters was implemented.
* Append operation (`&=`) for list types in configuration files was implemented.
* Support of executing testcases with default parameters from command line and configuration file was added.
* Improved error recovery for the compiler. E.g. it can now stop on the first syntactic error and skip the semantic analysis.

*Fixed bugs*

* *HP53582* Calling `Remove_Fd_All_Handlers` after `Remove_Fd_Read_Handler` causes error
* *HP57968* Designer: Running the compiled test without parameters can have unexpected effect
* *HP49044* Error window popup on any `Exclude/Include` operation in the workspace
* *HP70610* Reference search: does not find references in for loop header part
* *HP70600* Reference search: does not find local variables inside alt guard blocks
* *HP63161* Designer: `IllegalArgumentException` when creating TTCN3 files
* *HP40284* On-the-fly checker does not accept timer as log argument
* *HP55541* Single mode launcher runs in an arbitrary directory
* *HP55521* Eclipse Single Mode Launcher ignores config file
* *HP43578* Titan: faulty warning printout during compilation, "statement not reachable"
* *HP43572* Titan: fail to evaluate alt-statement (snapshot) correctly
* *HP22848* Titan compiler 1.8pl7 fails on Solaris10u10 with a "Too many files open "message.
* *HP38572* modulepar description in the Titan help is outdated, and not complete
* *HP39882* On-the fly checker: second imported definition of the same type is not recognized/stored
* *HP39843* on-the-fly checker: faulty transitive behavior of import
* *HP19155* UserGuide does not contain information for `-lutil` flag dependency in Makefile
* *HP38965* On-the-fly semantic checker doesn't accept `sizeof(X)` where X type is record of sth

[[version-crl-113-200-1-r9b]]
== Version CRL 113 200/1 R9B

Released on Jan. 24, 2012

*Fixed bugs*

* HP36538 was fixed. Incorrect handling of the := assignment in the `[DEFINE]` section of configuration files.

[[version-crl-113-200-1-r9a]]
== Version CRL 113 200/1 R9A

Released on Dec. 19, 2011

*New features*

* With the release we have decided to change from the proprietary Titan versioning scheme, to the one used by Ericsson. From now on it will be much easier to decide if a new version is forward, backward compatible with a previous version. The versioning is also supported in the attributes of the modules, with some limitations. We only accept version numbers in 3 formats: R9A, CRL 113 200 R9A and CRL 113 200/1 R9A.

* With this release we removed all QT based GUI parts (`mctr_gui`) and `ctags` from the official Titan releases, as they have been in maintenance phase for the last year. NEdit and XEmacs parts are still available as downloadable components from our download pages.

* The import of imports feature declared in the newest TTCN-3 standard was implemented. This way it is now possible to recursively import import statements from other modules.

* IPv6 support for Titan’s internal communication was implemented. This way Titan is now able to function properly when the MC and PTCs are located on an IPv6 network.

* The makefilegen tool in the command line package is now able to generate Makefiles from the information stored in .Tpd project descriptor files.

* It is now possible to find all reference pointing to a given declaration inside eclipse. Finding all references to a definition was implemented as a new kind of search in the Eclipse platform.

* The Executor plug-in will now be able to automatically merge the generated log files after execution.

[[version-1-8-pl7]]
== Version 1.8.pl7

Released on Oct. 10, 2011

*New features*

* The handling of XSD minOccurs and maxOccurs was updated to follow the upcoming version of the standard (4.3.2) with regards to the handling of optional alternatives of <choice> elements.

* The `testcase.stop` operation is now supported, allowing for the users to stop the execution of the actual testcase raising a dynamic testcase error with a custom explanation text.

* The `ispresent` predefined function was extended to operate on all structured types and fields as described in the 4.3.2 version of the TTCN-3 standard.

* We have re-implemented the `isbound` predefined function in way that is much more performance efficient than the previous one released.

1019
* The `encode_utf8` function of our universal charstring class became part of our public API, so it can now be safely used from C/{cpp} codes as well.
Elemer Lelik's avatar
Elemer Lelik committed
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145

* The indexing of string templates became supported.

* The main features of the LogViewer eclipse feature can no be accessed from the Project Explorer too, so it is no longer required to switch to its custom navigator.

* It is now possible to configure the Executor feature and eclipse executed "launch configurations" to automatically merge the log files that were generated during execution. For the case of several consecutive executions it is now possible to configure the system, to remove the previous log files before a new execution.

[[version-1-8-pl6]]
== Version 1.8.pl6

Released on Maj. 30, 2011

*New Features*

* With the new negative testing feature it is possible to generate invalid messages, and to send them to the SUT, to observe its reaction. For example mandatory fields can be left out, new data fields appended, value constraints can be violated.

* Emergency logging allows for the users to define logging behavior for normal and emergency situations. For example one could completely turn off logging for the normal case, while still receiving all needed logs in case of an error.

* The performance of the LogViewer eclipse plug-in was enhanced, so that now it no longer needs to store in memory all data of the log files to be able to display its content, neither in the table based representation nor in the Message Sequence Chart based representation.

* The LogViewer was also extended with support for searching and filtering in Titan generated lo files. Naturally this was also done in a way that blends naturally to the platform, so that users will not have to learn new ways of working.

[[version-1-8-pl5]]
== Version 1.8.pl5

Released on Dec. 17, 2010

*New Features*

* The TITAN logging architecture has been re-designed to support dynamic configuration and logger plug-ins. Currently only the legacy logger plug-in is supported, which creates backward compatible log files.

* Titan is no longer depending on the external Readline package. It has been replaced with Editline, which is now compiled into the delivered packages.

* A new feature for importing and converting MCTR_GUI project to Eclipse format was added.

* A new project description format has been created to support exporting and importing the data of Titan projects in eclipse into a single file.

* The LogViewer eclipse plug-in was enhanced to work on larger files, with less resource consumption. Also it is now much better integrated with the rest of the toolset.

*Backward incompatibilities*

TR number HM60511 raised our attention to the fact that according to the newest standard it is disallowed to index inside a matching different from "?" (See section 15.6.3 of the standard). This might make existing codes cause dynamic testcase errors at runtime.

[[version-1-8-pl4]]
== Version 1.8.pl4

Released on Aug. 13, 2010

*New Features*

* Unbound checking has been completely finished according to the standard.

* Huge speed increase and reduced memory usage was achieved in the Designer when the incremental parsing is turned on. Thanks to research efforts done in this field.

[[version-1-8-pl3]]
== Version 1.8.pl3

Release on July. 02, 2010

*New Features*

* Subtype checking for ASN.1 subtype constructions was implemented for the command line.

* A feature introduced into the 4.1.2 version of the TTCN-3 standard became supported, which allows the declaration and usage of not completely initialized record and record of values as long as the un-initialized element is not referenced directly.

* The `-v` flag of the generated ETS was enhanced to print the version information attached to the modules it was compiled from.

* Single mode execution was enhanced with automatic control part execution in case there is only one control part in the whole testsuite compiled into the ETS. In this case it is not necessary to provide parameters to the ETS when executed.

* Added support for the exclusive range bounds feature of the TTCN-3 standard.

* The name of the testcase will be displayed in the name of the log files of the MTC and HC if configured to be shown. Previously it was only displayed in the PTC’s logs.

* The execution of external script actions will always be logged in the MC, both before the execution and after the execution of the script, to indicate the range where execution has spent its time outside the TITAN generated code.

* The `*ttcn3_start*` script was extended to accept as an optional parameter the ip address it should start its communication on. This is useful when the computer running the tests is connected to several networks at the same time.

* We have started to re-work the logging of the runtime. At this time this should not have any effect noticeable for the users (Other than taking the name "Titan_Logger_Api").

* The subtype checking done on TTCN-3 modules in the previous release of the command line tools, was introduced into the Designer plug-in.

* When a new TITAN project is created as the last step of the wizard it will present the properties page of the new project.

* Launch shortcuts became supported by the Executor plug-in. This enables the user to create and initialize a new or reuse an old Launch Configuration simply by selecting a TITAN project or a configuration file for execution. The new launch configuration will be created and initialized to default values based on the data found on the project (if the Designer is also installed at the same time) and automatically launch the execution.

* It is now possible the exclude certain resources from the build by providing a global list of regular expression, that will be matched on the file names. If any of the expression matches on the name of a file, that file will be excluded from the build.

* It is also possible to configure the Project Explorer view to exclude the excluded resources and the working directory from its shown elements.

* In order to make it more apparent, why a given resource is not part of the build of the project, the exclusion decoration has been enhanced to describe the reason of exclusion.

* It is now possible to configure the Designer plug-in to do naming convention checks on the source code. The conventions can be configured globally, on project level and even on folder level if needed.

* The way of handling the path of the working directory, the generated executable and the makefile updater script was reworked so, that now it is possible to use environmental variables and Eclipse path variables in them too.

* As part of the previous item if the working directory is not present when the build is started, it will be created automatically.

* The Designer was enhanced to collect information about the compiler being configured as the actual build environment. If this setting is changed it will offer to rebuild all of the projects.

* The internal `Makefile` generator of the Designer was enhanced to support building a project without using symbolic links.

* It now supported to have several build configurations defined for each project. This way if one has a "debug" and a "release" configuration, one will be able to switch between the sets of build settings configured for each simply with a few clicks.

* The on-the-fly analysis of the Designer was extended to support delayed semantic checking. When this option is turned on, the on-the-fly semantic analysis will be only invoked when the users saves the file he was working on. While he is editing it only the syntactic checks will run. This mode enhances the performance of the tool, when one is editing framework libraries. However as the semantic database is not updated until the semantic analyzer is run, so will the code completion and other higher level functions also work with somewhat outdated data until the next `save` operation.

* The methods for building a TITAN project were introduced. In the first form the user is able to invoke the build process of Eclipse on a project from the command line, without activating any user interface elements. This mode will build the project on the exact same way it is done when the user is calling it from Eclipse. In the second form an xml file generated with all the data that might be needed to call the TITAN provided makefile generator. Using this form the user is able to create his own scripts, allowing to configure his build process in much finer detail.

[[version-1-8-pl2]]
== Version 1.8.pl2

Released on Jan. 29, 2010

*New Features*

* The base of the TTCN-3 standard used to describe the features and limitations of TITAN was changed from version v3.1.1 to v4.1.1

* The checking of subtypes in TTCN-3 was improved considerably.

* The semantic checking done by the on-the-fly analyzer in the Designer plug-in was enhanced to be on the same or higher level than present in the command line. A few checks are still missing as a limitation, but if the configurable checks are set several high level bugs/maintenance problems can be detected.

* A version checking mechanism was implemented, where TTCN-3 modules can have version numbers and place version requirements on imported modules, or the TITAN that is used to compile the actual module. Please also note, that as this feature introduces new syntax, earlier TITAN version will report an error for it.

* Support for dynamic linking was introduced into the build system. As in case of incremental modifications, sometimes most of the build time is spent with linking the object files to the final executable, eliminating this step can enhance build times in these cases. However this also means that the dynamic libraries must be transported together with the executable, as it will no longer work in a standalone manner.

* Dependency checking was enhanced in the build system. If using the new way, dependencies will be refreshed only for those modules that have changed, plus the dependencies on gcc are not tracked.

1146
* At build time the compiler can to split the generated code based on the types present in modules. When using the option "type", TITAN will create separate source files for the implementation code of the following types (for each module): sequence, sequence of, set, set of, union. In this case a common header file and a source file holding everything else will also be created. The amount of the generated files increases on this way, but as each of them is smaller the {cpp} compiler can compile them easier. As there are more files, the build process can run much more efficiently in parallel mode.
Elemer Lelik's avatar
Elemer Lelik committed
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423

* In the Designer plug-in the behavior of the content assistant can be configured by the user. Sorting of the proposals can be configured to be either alphabetical or relevance based. It is also possible to set the common prefixes of proposals, or in the case there was only 1 proposal found the whole proposal should be inserted automatically.

* The automatic insertion of closing apostrophes can also be configured.

* A new action was added to the TITAN actions toolbar, where the xsd2ttcn converter can be invoked on the selected files.

* The syntactic analysis of files was enhanced to become parallel, allowing several times faster operation on machines having several computational cores. For example a dual core processor (commonly present nowadays) will be able to parse two files in parallel.

* The show view menu of the plug-in's default perspectives was extended with links to views commonly present in the perspectives, to help faster navigation.

* In the internal makefile generator the `OPENSSL_DIR` and the `XMLDIR linker` search paths can be disabled, in case the users wish to set their own libraries.

* The reporting of syntax errors in extension attributes became configurable. According to the standard if TITAN is not able to perfectly understand an extension attribute, it should assume that it was meant for a different tool instead of reporting errors, but in this case typos could not be reported to the user.

* In the build process if the working directory does not exist when the build is started, but is set to be contained directly in the root of the project, it will be created automatically. And after the build has finished its contents will always be refreshed automatically, to represent the contents of the actual file system.

* Also in the build process, just before executing the external command the `derived` flag of the working directory will be set automatically (users could set this by hand till now). Setting this flag should mean for other plug-ins, that the contents of this folder should be treated specially, for example they will be left out of search results, and version handling plug-in should also ignore them. This together with the previous feature allows better interoperability with version handling systems, as in this case the working directory no longer needs to be handled by the version handling system in most of the cases.

*Fixed bugs*

Several bugs found both in the xsd2ttcn converter and in the XML encoder/decoder were corrected.

[[version-1-8-pl1]]
== Version 1.8.pl1

Released on Sept 11, 2009

*New Features*

* Added support for the module interface feature of the TTCN-3 standard (version 4.1). Allowing for the users to assign visibility attributes to definitions.

* Added the `testcasename()` predefined function, which returns the name of the actual testcase or an empty character string.

* The `sizeoftype()` predefined function was removed in accordance with the new TTCN-3 standard.

* Introduced the *FILE* and *BFILE* pre-processor macros, which are replaced with the canonical path of the file, and the name of the file respectively.

* The meaning of the *SCOPE* macro is changed to comply with how it has appeared in the standard. In the new operation it will be replaced with the name of the lowest named basic scope unit in which the macro is used.

*Fixed bugs*

In the Designer plug-in the `extends` extension attribute was parsed incorrectly.

[[version-1-8-pl0]]
== Version 1.8.pl0

Released on Jun 12, 2009

*New Features*

* Support for XML encoding and decoding is introduced, together with a new command line tool that converts XSD files into TTCN-3 modules.

* The TTCN-3 type Anytype is now supported with some restrictions (see section 4.2 of the link:https://github.com/eclipse/titan.core/tree/master/usrguide/referenceguide[Programmer Reference Guide]).

* A new runtime was introduced, that requires much less code to be generated and compiled at the cost of minor decrease in runtime performance. The original runtime is advised to be used in load test scenarios (for this it is called load test runtime), while the new runtime is advised to be used in function test scenarios (for this it is called function test runtime).

* The internal handling of extension attributes was redesigned. The original analysis of these attributes was dependent on the location where they were found (so the same extension was accepted for a function but rejected for a type). This behavior was changed to accept all extension attributes, and only report an error if the attribute is located at the correct place, but contains some semantic errors in itself.

* Several predefined functions were extended to be able to accept templates as parameters (`encode`, `replace`, `substr`).

* Index assignment notation became supported in base templates

* With the addition of the *SCOPE* macro TITAN will now support all TTCN-3 macros defined by the upcoming TTCN-3 standard (version 3.4)

* The speed with which PTC were created was enhanced. Compared to 1.7.pl3 there was a noticeable slowdown in 1.7.pl4. With this improvement PTC should be created faster than in 1.7.pl3.

* All operations are now supported for big integers too.

* The `enum2int` predefined function was implemented

* The `setverdict` predefined function was extended with an optional `charstring` parameter where the users can specify the reason of setting the verdict.

* The implicit omit attribute feature of TTCN-3 was implemented

* A new option was introduced to the compiler to emulate more precisely the warning/error message format of gcc, so to make it integrate with eclipse much better.

* Concatenation of patterns became supported, and from now on patterns can reference templates too.

* The encode, decode predefined functions were implemented.

* `Inout` parameters became supported when functions are started.

* The automatic postfixing of identifiers was introduced, to be able to refer to assignment in ASN.1 modules which have a name that is a keyword in the TTCN-3 language.

* We added support for several features that operate on list types (set of, record of and arrays) including: `concatenation`, `rotation`, `substr`, `replace` and `lengthof`.

* Both Eclipse plug-ins were enhanced with the ability to format and merge log files, in the form of two new actions available in the TITAN menu.

* The executor plug-in was extended to report an error if an executable was set for a launch configuration that is not able to use it (for example an executable compiled for single mode execution can not be executed in parallel mode).

* It is now possible to set, that when the external TITAN action actions are executed on a set of file, they should not process those that are excluded, or are inside excluded folders.

* It became possible to configure what should happen to the markers reported by the compiler, once an on-the-fly analization was executed.

* It is also possible to handle the on-the-fly reported error markers as fatal for build, meaning that as long as the on-the-fly analyzer is reporting an error on a project it will automatically fail the build process. Running the build in such cases would most probably also end up reporting the very same error, but would take a long time to do this.

* It is possible to configure the severity with which the unused function return value problem should be reported.

* The "go to matching bracket" feature was implemented.

* The Designer plug-in was enhanced to detect the number of processing resources possible to use in a build, and as such is able to drive the build process to use several parallel threads. This should result in the decrease of build times, for user who have not yet manually configured their system to do so.

* Introduced the "Treat `.ttcnpp` files as `.ttcn`" feature. If this is enabled the on-the-fly analyzer will try to analyze `.ttcnpp` files as if they were ordinary TTCN-3 files. If the `.ttcnpp` files do not contain any pre-processing macros, but can not be renamed for external reasons, this feature will greatly enhance the user experience. If the files do contain pre-processing macros than enabling this feature will only mean a change of reported errors.

* The Designer plug-in is able to check the validity of the license file, to display the data contained within, and to warn the user a few days before the expiration of the license.

* Enhanced the code quality checks to detect unused definitions and assignments, both on module level and in local scopes. These two scopes has to be separated as unused local definitions always indicate an error, while unused module level definitions might be completely valid in library modules.

* The on-the-fly semantic checker of the Designer plug-in was enhanced considerably.

* The Designer plug-in was enhanced with the ability to incrementally parse TTCN-3 files. This means that after the first time there should be no need to syntactically re-analyze the whole file, but the tool will be able to decrease the amount of data to be re-analyzed to about a few lines. This will not only decrease the time required to re-analyze a project from a few seconds to a few times 10-2 seconds, but will also stop the outline from collapsing after each change in the file.

* The Designer plug-in was extended with an internal makefile generator which uses the data collected by the on-the-fly analyzer. Using this makefiles can not only be generated faster, but the way the makefile is generated can be configured very precisely for each project. When used properly makefiles generated this way should not need to be changes later with makefile updater scripts.

* The on-the-fly analyzer was enhanced to adapt to changes in the file system. So if a new file is added to the project it will be analyzed automatically (earlier a file had to be opened in a supported editor).

*Fixed bugs*

* There was a slowdown in component creation.

* When the `Log match` operation was used, with the matching hints option set to compact, and the mismatch between the value and the template was contained somewhere within a union type, there was actually no information logged by the operation.

* Some special big integers could be encoded or decoded incorrectly in internal communication.

* The `install_handler` function did not handle correctly the case when a user closed a file already having a handler, then opened a file with the very same file descriptor, and tried to install a new handler on it.

[[version-1-7-pl4]]
== Version 1.7.pl4

Released on October 03, 2008.

*New features*

* Template restrictions from the coming TTCN-3 standard (version 3.3.1) was implemented, allowing a finer specification of templates.

* A new predefined function called `log2str` was introduced. This function works like the original log function, accepting any number of parameters of any type. But the character string created with the concatenation of the parameters is not logged in a file, but returned as a charstring.

* The `replace` predefined function was implemented for all string types.

* Two new keywords from the coming TTCN-3 standard (version 3.3.1) were implemented : break and continue. Using these constructs it will be easier to create simple to understand loop sequences, as the loop condition can be simplified (INCOMPATIBLE).

* The connection handling on both the Main Controller and the Parallel Test Component side was enhanced with using an epoll based mechanism. On the Linux based platforms where this feature is available the users will be able to create as many connections as they want without the need to use a special build of TITAN. The overhead of using thousands of connections compared to using only a few will be almost non-measurable.

* The testport API was also redesigned to support this new feature gained by using the epoll functionality. This way the above mentioned benefits will also be present for the testport writers. For backward compatibility reasons the old interface is kept, meaning that existing testports does not need to be changed. However, using the old interface the testports will not be able to use the new possibility to its fullest.

* The logging of the `match` operation was made configurable through the `MatchingHints` logging option. If it is set in "Compact" mode (which is the default) the log record will be only a few lines long, instead of a few hundred lines long. In fact if there is only one field mismatching than the log will contain 1 line regardless of the size and structure of the value and template compared.

*New features added to the Eclipse plug-ins*

* The semantic data stored by the on-the-fly toolset about TTCN-3 files was increased to be about at the same level as the compiler is. Minor items like storing the 'with attributes' is missing, but other than that every structure is in place. This change was used as base for other features, and will serve as the base of the whole infrastructure we are going to build.

* The on-the-fly semantic checker was enhanced considerably thanks to the increased amount of data available. This allows the fast detections of lost of much more semantic errors, reducing the number of builds the users have to have dramatically. Because full semantic checking was not an aim of this project, and storing data coming from ASN.1 modules is not yet fully supported, the on-the-fly semantic checker can not be complete. The missing parts include areas like the checking of actual parameters, or checking the existence of return statements.

* We have implemented a few code quality checks in the on-the-fly semantic checker, which can detect a few inefficient structures: loops whose entry condition never evaluates to true, value shifting or rotation that actually does not change the value, etc…

* Seeing that now there are projects containing hundreds of modules, we implemented a heuristical check for superfluous import statements. In several cases import relations were declared between modules that did not actually import any definition from each other. This only complicated the understanding of the relations between modules, and put an unnecessary constraint on the incremental build system. This function is not a full functionality, as the on-the-fly semantic check is not complete, it can also not be complete. For this reason the reported severity of such problems was made to be user configurable (it can be set to be an error, or warning, but can also be turned off).

* Even though we have increased the amount of data stored in the memory, we have managed to decrease the overall memory consumption. This is mainly the result of completing the on-the-fly structure for the TTCN-3 modules, as with the whole structure and the better semantic checker in hand we could already implement several optimalizations.

* The jump to definition was also implemented for configuration files. This way it is now possible to jump to definitions inside the configuration files, or to module parameters receiving value in the module parameters section.

* The standard outline view found in Eclipse is now supported for TTCN-3 and ASN.1 modules. This way the user can see an outline of the structure of his module to better understand it, or to find the declaration of definitions much faster. This outline view can not only be used to sort and filter the definitions in a way best suited for the user, but by clicking on an element displayed can be used to instantly navigate to the searched feature.

* An other long existing and wished for feature that we now started to support was what Eclipse calls "project references". In this feature the user can set the dependencies of projects inside Eclipse and from then on both the build processing and the on-the-fly checking of these projects will handle them automatically as dependent projects. This not only allows the partitioning of larger projects into smaller, more concise parts, but also allows to do this in a file system independent manner. For example a new project just existing on the users computer might depend on other projects stored in several different version control system around the world, as long as each project is set up to be working correctly in a standalone manner, they can be connected into much bigger project hierarchies.

* We have introduced two more build levels in the Designer plug-in (level 2.5 and 4.5) which use a heuristic algorithm to decide when the dependency relations of modules needs to be refreshed. Using this feature the users don’t need to choose between the safety of refreshing the dependency hierarchy, and the speed when not doing so. When all of the source code used in the module is handled by the on-the-fly analyzer, the dependency data will be tracked, and the slow external dependency update will only be called if needed. However if not all sources are handled by the on-the-fly analyzer, or the situation is not perfectly clear it will always decide to do the dependency update as otherwise the generated code might not compile correctly.

* We have also implemented a text hover functionality. When the user holds the mouse cursor over a definition for long enough, the information displayed about the definition in code completion, will be displayed in a hover box. This way to find out the type of a definition, the user only needs to hold the mouse above it for a short time, there is no need to actually jump to declaration of the definition.

* Since the on-the-fly toolset started to report syntactic and semantic errors, there was always the problem of different errors being reported. The compiler doing the full semantic checking was doing a much better check, but the on-the-fly toolset was working with the actual state of the file. This resulted in situations where the error marker of the compiler was already outdated, or when the tools had their error markers on single error (detected by both). This was now changed, by making the problems reported by the compiler "outdate" after the user has edited the file. This way the markers will still be there, so the user will be able to find other errors to correct, but the gray color of the outdated markings will indicate that the problem might already have been corrected.

* The `mctr_cli` based execution mode was extended to support automatic execution via tracking the state of the underlying `mctr_cli`, through the command line.

* All executor modes were extended to support the execution of control parts as members of test sets.

* Both the Designer and the Executor Eclipse plug-ins received a graphical refresh. All launch modes, definitions and other outline elements, invocable external actions received their very own distinct icons.

*Fixed bugs*

* The matching of a value containing the omit value, was not handled correctly when the template had a list or a complemented list in the position. The required functionality was not implemented in the generated code, but only the base library.

* When an interleave was embedded in another interleave the generated code was incorrect. If one branch of the embedded interleave was executed it was handled as if all branches of the embedded interleave would have been executed.

* Although TITAN allowed the referencing of global definitions without specifying the module name inside patterns, but not charstring fields of structured constants or using with the module name prefix.

* In certain situations, when a returning function had a too complex branching hierarchy implemented, sometimes the compiler was not reporting paths without a return statement as an error, but as a simple warning. This caused that even though there was no return statement, the code was compiled without problem, and when the execution of the function finished it returned with some memory garbage. This case, when the compiler noticed that something was wrong, but could not decide if it really was wrong or not, was promoted to an error level, to provide safe operation. This is not a backward compatible change, but well written source code, should not need any changes (INCOMPATIBLE).

* The values assigned to templates of signature types were not checked semantically, and so corrupted code was generated.

* In very complex, self-reflexive type structures the semantic checking of the compiler could mark the start function of startable functions as generated, without actually generating it. For this reason the generated code was sometimes erroneous, as the function call could be generated, but the function itself was not.

* The `isvalue` predefined function was working incorrectly for array templates, as the specific functionality was not implemented, and so the general implementation included in the base libraries was executed.

* The code generated for timer array was very inefficient as the name of each timer was generated separately in the code. In case of a timer array containing 20 million timers this resulted in a so big generated source file, that gcc was not able to compile it.

* In the Executor Eclipse plug-in there was no error report if the command used to create the Host Controllers was erroneous. This was simply caused by the fact, that the output appearing in the console was only reported on the user interface one the Host Controller was started, as in this case it was not able to start the contents of the output reading stream were cleared too early.

* The `ttcn3_start` script had no error handling procedure if the error appeared right after trying to execute the `cmtc` command. Which in some cases caused it to keep waiting for the good results indefinitely long, instead of exiting.

* The self component reference was only usable in function which had a runs on clause. This was too restrictive as the standard allows such usage.

* When the system component was used in the connect operation the semantic checker reported a rather un-intuitive error message, which had to be rephrased.

* The `is_bound` function was not generated for some types when the usage of older naming conventions was specified by the user.

* In the Designer Eclipse plug-in the configuration of TITAN to use default values as option always only implemented in the main build system, but other external operations like the testport generation was not configurable with this option.

* In some case the On-the-fly parser of the Designer plug-in was reporting syntactic error for syntactically correct named parameter constructs as a result of an incorrect grammar rule.

* The compiler was not checking the compatibility of runs on components if the function with incompatible runs on component was called inside a log statement inside a function. This check was simply not implemented for function calls placed in log statements.

* Because of a minor bug the pattern #(,1) was not accepted directly in template patterns.

* Because of an error in the Executor Eclipse plug-in, in single mode execution when the input configuration file was syntactically erroneous it was not reported, and the execution was not stopped, but temporary configuration file was generated erroneously.

* TITAN, as a nice feature, was implicitly concatenating character strings which turned out to cause problem, as in case of list of strings, the missing of comma sign was not reported as a syntax error, but the list was created with less elements (as the string where the comma was missing were concatenated).

* We have found an interoperability problem related to the ClearCase Remote Client in the Designer Eclipse plug-in. As the problem was found to be on the side of the Remote Client an error report was sent to IBM, and a workaround was implemented in our plug-in.

[[version-1-7-pl3]]
== Version 1.7.pl3

Released on March 10, 2008.

*New features*

* When calling a function, altstep or testcase it is now possible to provide the actual parameters in a different order than the formal parameters were defined. If the each actual parameter exactly qualify to which formal parameter they should be assigned to.
* Now it is possible to use array indices within assignment notations.
* A new flag `-d` was introduced for the compiler to enhance interoperability with other implementations of the ASN.1 standard. When this option is provided the compiler will handle fields of set and sequence types having a default value as if they were optional. This means that these fields will be omitted when encoded, and will not be expected at decode time.
* A new predefined function called `isvalue` was introduced. Using this feature it is now possible to check if a template can be converted to a value with the `valueof` operation or not. As calling `valueof` on a template which did not contain an exact value resulted in a dynamic testcase error.
* Concatenation of binary strings is now possible in the runtime configuration file.
* To further enhance the logging utilities it is now able to split huge logfiles at the time of generation based on options set by the user in the runtime configuration file.

*New features added to the Eclipse plugins:*

* An on-the-fly parser for runtime configuration files.
* A basic on-the-fly parser for ASN.1 .
* Low level semantic code analysis for TTCN-3 and ASN.1 modules.
* The "Jump to definition" and "Open declaration" features were enhanced to work in ASN.1 modules too. Now it is also possible to cross the borders between the 2 module kinds, allowing for the user to jump to a declaration in an ASN.1 module, from a TTCN-3 module where it is used.
* The runtime configuration file editor was enhanced to offer not only textual editing possibilities for the user, but also some graphical editing functionalites. The graphical pages of the configuration file editor were organized according the sections in the file format, trying to provide a clean separation for informations that are not directly related. Each graphical page was designed to simplify the most common operations, for example on the logging page the user can change the logging settings with simply selecting the categories they wish to be logged out, or deselecting the ones that should be left out.
* The icons of the different supported file formats, and callable command line operations were re-designed, to provide a much better user interface, where the users can find the oprations they wish to invoke simplier and faster.

*Fixed bugs*

When a constant universal charstring value was assigned to a charstring the compiler did the assignment with reporting any problems, however if there was a complex expression resulting in a universal charatring on the right side the compiler reported a semantic error. This inconsistent state was resolved by reporting a warning for the first case too. This is only done to give some time to the user to make the necessary changes before an error will be reported for that code, making it un-compilable.

[[version-1-7-pl2]]
== Version 1.7.pl2

NOTE: This is was an intermediate release, required by the TitanSim project.

Released on November 30, 2007.

*New features*

* A new function and altstep reference type was introduced called "runs on references". This allows the reference touse resources defined by the runs on clause of the actual function or altstep, when it is called using the apply statement.

[[version-1-7-pl1]]
== Version 1.7.pl1

NOTE: This is not a released version, only a delivery, delivered on August 27, 2007.

*New features*

T* he log event subtypes were introduced, allowing finer log settings.

* Type mapping rule discard has been introduced in dual-faced ports, which allows conditional or unconditional dropping of messages while translating them between the external and internal interfaces.

* Automatically generated TTCN–3 external functions used for encoding and decoding have been enhanced: The functions generate debug printouts with event type DEBUG ENCDEC before and after invoking the codecs. The decoder functions report a warning if superfluous data remained in the buffer after successful decoding.

* The translation of TTCN–3 regular expressions has been significantly enhanced in the compiler and the run-time environment: The character sets are verified and duplicate members are reported. Support of quadruple notation has been added for character codes between \q_{_0,0,0,1_} and \q_{_0,0,0,255_}. The generated POSIX equivalent is optimized to be shorter and simpler. +

NOTE: TTCN–3 regular expressions are used by the matching mechanism pattern in templates of type charstring, the arguments of predefined function `regexp()` and the attributes of TEXT encoding.

* Non-standard additional predefined function `unichar2char()` has been introduced.

1424
* The run-time realization of TTCN–3 additional predefined functions has been enhanced. New polymorphic versions have been introduced to eliminate the conversion of arguments in {cpp}. The error messages generated by these functions have been rephrased to make the reason of the failure easier to understand.
Elemer Lelik's avatar
Elemer Lelik committed
1425
1426
1427
1428
1429
1430
1431

* Utility `*ttcn3 logformat*` supports the indentation depth of zero. Option `-i` 0 eliminates the previous indentation made in the file so that each log entry is printed in one line.

* The semantic analyzer of the compiler checks the TTCN–3 and ASN.1 modules in bottom-up order, which means the analysis of a module is started only after the checking of all imported modules is completed (except in case of circular imports). This new checking strategy results in shorter and more straightforward error messages because the irrelevant context information is not printed anymore. The original algorithm processed the modules in the same order as they were given in the command line. So when the first module was referring to a faulty definition in a module given later the context information of the error message pointed to both modules although there was no error in the first module.

* The meaning of metacharacter `%n` within the log file name skeletons has been extended. It is substituted with the string `_MTC_` in single mode and on the MTC, with string `_HC_` on the HCs or with the name of the PTC if it was given one when it was created. Formerly, this metacharacter had useful value only on PTCs.

1432
* The status of module parameter values given without module name in section `[MODULE PARAMETERS]` of the configuration file has been clarified. The ambiguity was introduced in the previous release, 1.7.pl0, in which the new {cpp} naming rules allow the definition of module parameters with identical names in different modules. If the module name is omitted or substituted with an asterisk character (*) in the configuration file the value will be set in all modules that have parameter with the given name. Error occurs if none of the modules contain module parameter with the that name. Unless the module name is given in the configuration file the run-time environment assumes that all identically named parameters have the same type.
Elemer Lelik's avatar
Elemer Lelik committed
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459

* The following enhancements have been made on the GUI:

* The speed of automatic refresh operations on the execution window has been significantly increased. In former versions the window was refreshed after every change in the TTCN–3 test configuration, which could lead to significant delays in the GUI if the test configuration has changed too frequently (like in case of complex load test setups).

New features added to the Eclipse plugins:

* Code completion:

* Became type structure sensitive in TTCN–3 modules, allowing it to complete the fields of structured types in references.

* Became scope sensitve in TTCN–3 modules offering only proposals which could be used in the actual scope.

* Was enhanced with pre-defined skeletons in `asn1`, `ttcn`, `ttcnpp`, `ttcnin` files.

* Was enhanced with type specific, dynamically generated skeletons in ttcn files (for example function calls can be completed with the short version of the formal parameter list of the function).

* Wizards were introduced to help the creation of TTCN–3 , ASN.1 modules and configuration files.

* Changes done to a document in one editor are reflected in every other editor too, where the same document is being edited.

* Syntax coloring changes no longer need to be applied one by one.

* The help system of the Designer and the Executor plugins was separated.

*Fixed bugs*

1460
* The generated {cpp} equivalent of enumerated types could not be compiled with GCC 2.95.x if the new naming rules were in effect. The problem was caused by the {cpp} enum type that was declared within the scope of the {cpp} class representing the values of the enumerated type. The old version of GCC accepts the casting operator only if the name of the embedded enum type is prefixed with the name of the {cpp} class.
Elemer Lelik's avatar
Elemer Lelik committed
1461
1462
1463

* When logging the matching procedure of optional fields in record and set types the field of the value and the template was printed in the wrong order if the field of the value was set to omit. Always the value must be printed first during matching, which corresponds to the order of arguments in built-in operation `match()`.

1464
* The compiler generated wrong {cpp} code for repeat statements found within the response and exception handling parts of call statements. If the call statement was embedded into an altstep the generated code assumed that the repeat statement refers to the whole altstep. Otherwise the generated {cpp} code was erroneous, it could not be compiled.
Elemer Lelik's avatar
Elemer Lelik committed
1465
1466
1467
1468
1469

* The copy constructor of class TTCN Buffer did not work properly in the Base Library. This class is used by the common API for encoding and decoding. The defective copy constructor did not copy the length indicator field of the buffer to the newly created object thus some manually written codec functions and Test Ports reported mysterious internal error messages.

* The semantic analyzer of the compiler reported false error messages while checking procedure-based operations `catch(timeout)`. Although this operation is applicable after calling any blocking signature the compiler accepted `catch(timeout)` only if the regular catch operation was allowed (i.e. the corresponding signature had at least one exception type). Of course, the operation `catch(timeout)` is allowed within the response and exception handling parts of call operations and only if the respective operation has a call timer.

1470
* The compiler generated erroneous {cpp} code for the construct _value returning done_ if the new naming rules were in effect. The invoked {cpp} function was not prefixed with the appropriate namespace if the done statement and the return type of the PTC behavior function (having attribute with _{extension "done" }_) were defined in different modules.
Elemer Lelik's avatar
Elemer Lelik committed
1471
1472
1473
1474
1475

* Erroneous circular TTCN–3 type references pointing back to themselves with field or array sub-references (like type T[0].f1 T;) caused infinite recursion in the semantic analyzer and consequently the compiler crashed with segmentation fault.

* The utility `*ttcn3 logbrowser*` mis-interpreted some log entries. If the text of the log entry contained only a small integer number (like 1 or 2) the log browser presented the number as an erroneous component reference and left the field for the event text empty.

1476
* The generated {cpp} code related to TTCN–3 expressions comparing optional fields of record and set types was erroneous in some cases. If two optional fields were tested for inequality the generated code could not be compiled with GCC 4.0.x or later. GCC complained about ambiguous overloading of operators. Furthermore, if an optional field containing a value of type charstring was compared with an optional field containing universal charstring the {cpp} code caused infinite recursion at runtime. All these errors were related to the instantiation of template member functions of {cpp} template classes.
Elemer Lelik's avatar
Elemer Lelik committed
1477
1478
1479

* The semantic analyzer of the compiler did not check properly the value list and value range (i.e. character range) type restrictions of type universal charstring. Even some basic checks, such as the verification of range boundaries and overlapping, were skipped in previous versions.

1480
* The compiler generated incomplete {cpp} type descriptor structures for some TTCN–3 types, which could lead to segmentation fault in the run-time environment during encoding or decoding using the built-in RAW or TEXT codecs. For example, if a type alias was created for type charstring with a fixed length restriction, but without coding attributes then the type descriptor of the aliased type contained information only for RAW encoding. The information about TEXT coding was not inherited from the built-in type charstring. If this aliased type was embedded into a structured type with appropriate TEXT coding attributes the TEXT encoder and decoder operations on the structured type would crash with segmentation fault.
Elemer Lelik's avatar
Elemer Lelik committed
1481

1482
* The compiler generated erroneous {cpp} initializers for literal values of type charstring containing NUL characters (i.e. characters with character code zero). The length of the strings was set correctly in the run-time environment, but the characters of the string contained memory garbage after the first NUL character.
Elemer Lelik's avatar
Elemer Lelik committed
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495

* The algorithm that translates TTCN–3 regular expressions to their POSIX equivalents handled the TTCN–3 character set expressions incorrectly. Neither individual characters nor character ranges of the set were mapped properly (using the appropriate escape sequences) to POSIX. The resulting POSIX character set was sometimes faulty or had different meaning than the original TTCN–3 set. This problem affected the matching mechanism pattern in templates of type charstring, the arguments of predefined function `regexp()` and the attributes of TEXT encoding in both the compiler and the run-time environment.

* The TTCN–3 test components could terminate with a dynamic test case error if their communication partner terminated while a `disconnect` operation was in progress on an existing port connection. If sending an internal protocol message requesting the connection termination fails on a socket connection only a warning message is displayed rather than an error. This change makes the shutdown process of complex test configurations more robust.

* Utility `*ttcn3 logmerge*` could crash with a segmentation fault when it was run on several input files and one of them contained only one log entry.

* The semantic analyzer of the compiler could report false error messages complaining about missing return statements within functions having return type. This was the case, for instance, if the function contained an infinite loop without return statement realized using a goto statement. Such code fragments should not be considered faulty.

* The RAWcodec of the run-time environment crashed with a segmentation fault while decoding an integer value encoded on more than 16 octets (i.e. the value of attribute `FIELDLENGTH` was greater than 128).

* The semantic checker algorithm that verified attribute user of dual-faced port types was incomplete. The compiler did not report any error if a source type of an in or out mapping was not present on the message list of the respective port type.

1496
* The decode type mapping rules of dual-faced port types did not consider the associated `errorbehavior` attribute. The reason was that the {cpp} equivalents of the errorbehavior settings were left out from the generated code by mistake.
Elemer Lelik's avatar
Elemer Lelik committed
1497

1498
* The default argument of the constructor (NULL pointer) was missing from the generated {cpp} classes implementing TTCN–3 ports if the respective TTCN–3 port type had attribute provider or user. Because of this the compilation of the generated {cpp} code failed when a TTCN–3 port array was created from the above port types. The {cpp} template class that realizes port arrays tried to instantiate its elements using the default constructor (i.e. without parameters).
Elemer Lelik's avatar
Elemer Lelik committed
1499
1500
1501
1502
1503
1504
1505

* The command line version of the Main Controller (i.e. `mctr cli`) crashed with a segmentation fault after encountering the expansion of an invalid macro to a host name (e.g. $_{NonExistentMacro, hostname}_) in the configuration file. The crash occurred after reporting the appropriate error message. The reason was an uninitialized variable.

* The semantic analyzer routines of the compiler that check the correctness of the RAW and TEXT codec attributes did not work properly in some very rare cases. The problem occurred when a field of a structured type was a referenced type pointing to another referenced type, which was an alias of a built-in type and neither types had encoding attributes. After checking this construct the internal memory structures of the compiler remained in an invalid state, which caused an internal fatal error during code generation.

* The error message of the compiler pointed to the wrong location in the source file if a (named) TTCN–3 constant was assigned to a variable and the actual value of the constant violated the subtype restrictions in the type of the variable. In this case the error message pointed to the literal value of the constant (which was apparently correct) rather than the faulty variable assignment.

1506
* The Base Library lacked the {cpp} functions and operators that can implicitly convert a template (or template variable) of type charstring to a template of type universal charstring by translating the embedded matching mechanisms character-by-character. TTCN–3 modules using such constructs were accepted by the compiler, but the generated {cpp} code could not be compiled due to ambiguous overloads of operators. To resolve the problem a new constructor and assignment operator have been added to class UNIVERSAL CHARSTRING template, both taking CHARSTRING template as argument.
Elemer Lelik's avatar
Elemer Lelik committed
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528

* Although the ASN.1 front-end of the compiler ignores all type constraints except the table and component relation constraints of open types, some valid type constraints were rejected by the parser. False syntax errors were generated, for instance, if a single value constraint contained values within brackets (such as `SEQUENCE` or `SET` values) or a permitted alphabet constraint (denoted by keyword FROM) contained single characters using the quadruple notation.

* The following bugs have been fixed in the GUI:

* Configuration file macros were not substituted in sections that are processed locally (such as `[MAIN CONTROLLER]`, `[GROUPS]` and `[COMPONENTS]`). Macro substitution was inefficient in the rest of the sections.

* Fixed bugs in the Eclipse plugins:

* Coloring of multi line comments in ttcn3 files could get corrupted. This was corrected by using the on-the-fly parser created intervals to identify its exact location.

* Faster operations in general.

* Calling errors of the native win32 commands corrected.

[[version-1-7-pl0]]
== Version 1.7.pl0

Released on March 9, 2007.

*New features*

1529
* The naming convention of the generated {cpp} code has been revised to avoid name clashes between different definitions. The use of a {cpp} namespace for each module eliminates all compilation problems caused by definitions with the same identifier in different modules. The proper scoping of enumerated values excludes the name conflict between two enumerated types and makes the enum-hack option unnecessary and obsolete.
Elemer Lelik's avatar
Elemer Lelik committed
1530
1531
1532

* Extensibility (inheritance) of TTCN–3 component types and type compatibility between different component types is now supported by the compiler.

1533
* The compiler can generate TTCN–3 external functions automatically in {cpp} to perform encoding and decoding of message types using the built-in codecs of the runtime environments. {cpp} programming is no longer necessary to create a complete and working protocol module. All options of the encoding shall be given in TTCN–3 as attributes of the external functions.
Elemer Lelik's avatar
Elemer Lelik committed
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570

* Dual-faced TTCN–3 ports are now supported. Such ports have two different interfaces: internal (used when sending and receiving messages) and external (used when connecting the port to another test component or mapping to a system port). The handling of incoming and outgoing messages shall be specified using type mapping rules in the attributes of port types.

* Code generation for mixed port types is now supported.

* The expect script `*ttcn3 start*` has been improved:

* The script uses a built-in function to obtain the name of the computer rather than launching the command hostname, which results in faster and more reliable operation.

* Zombie processes are no longer left during the script run.

* Error handling has been enhanced, which avoids deadlocks in various error situations.

* It is no longer required to have identical names of formal parameters to the corresponding function, altstep or testcase type for the function, altstep or testcase referenced in a `refers` operation. Only the direction and the type of parameters must be identical. Different parameter names will generate warnings rather than errors.

* Formerly, the semantic analyzer of the compiler reported two consecutive error messages when it found duplicate definitions with the same identifier. Now it reports a single error message because this is a single fault. The location of the clashing definition is given as a note following the error message. Hence the counter printed at the end of compiler run shows a more realistic information about the number of errors.

* The visualization of template matching in the log files had contained the corresponding value and template fields in a misleading order. In built-in operation match of TTCN–3 the first argument is a value and the second is a template, but in the log printout the fields of the template was given first followed by the value. The order of the log printout has been reversed to be consistent with the TTCN–3 syntax.

* The status of TTCN–3 special type address was clarified.

* The BER decoding of ASN.1 type UTF8String was significantly enhanced. The newly written decoder is able to detect all possible violations of the UTF-8 character encoding and to report appropriate error messages. Error recovery is also supported, that is, an incorrectly encoded character will not prevent the decoder from processing the rest of the string. The former algorithm caused buffer over-indexing, which led to non-deterministic results, if one or more octets were missing from the end of the received octet stream.

* The compiler supports the latest official TTCN–3 language syntax according to the BNF published in version 3.2.1 of link:https://www.etsi.org/deliver/etsi_es/201800_201899/20187301/04.01.01_60/es_20187301v040101p.pdf[Methods for Testing and Specification (MTS); The Testing and Test Control Notation version 3. Part 1: Core Language]. The only significant change is that the new BNF allows multiple external constant definitions with the same type separated by commas.

* The Runtime GUI is no longer part of the TTCN–3 Executor package. It has become a stand-alone product with number CNL 113 437 and its own version numbering.

* The following enhancements have been made on the GUI:

* A red 'X' is drawn on the symlink icons of files in the project if the related symlink does not exist, but it should.

* Excluded files are not passed to the `Makefile` generator, and will not be present in the `Makefile`.

*Fixed bugs*

* The compiler reported an error if the argument of TTCN–3 built-in operation `ischosen` was a value or template of an ASN.1 open type. ASN.1 open types should be visible from TTCN–3 as union types.

1571
* The compiler generated wrong {cpp} code for port operation `getreply` if the corresponding signature had return type, but the operation did not specify a value match. The lack of value match means that all possible incoming return values should be accepted by the operation. However, when the referred signature template was nonparameterized the generated code matched the return value against the value match specified in the previous `getreply` operation referring to the same signature template.
Elemer Lelik's avatar
Elemer Lelik committed
1572
1573
1574
1575
1576

* The compiler aborted with an internal fatal error during semantic analysis when a function or altstep type had a timer formal parameter.

* The error message of the run-time environment was misleading when trying to convert a record or set value containing an unbound optional field to a template of the corresponding type because the message referred to built-in function `ispresent`. The reason was that the internal realization of the value to template conversion was based on `ispresent`. The conversion algorithm has been rewritten to give a more straightforward error message.

1577
* The semantic analyzer of the compiler did not verify the compatibility of component types when checking the component references returned by built-in operations `create`, `self`, `mtc` and `system`. For example the compiler was unable to detect if a component reference returned by create was assigned to a variable of a different component type. The {cpp} code generated from invalid input could be compiled to executable, but the component operations following the erroneous statement could result in run-time errors.
Elemer Lelik's avatar
Elemer Lelik committed
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639

* The implementation of TTCN–3 operation any `component.done` was incorrect in the Main Controller. The MC gave false positive answer to the MTC if there was a PTC that was just created, but not yet started.

* The `Makefile` generator program `*ttcn3 makefilegen*` could not cope with binary files (object files, executable programs, etc.) given as command line arguments. The program entered an infinite loop while trying to determine whether the file contains a valid TTCN–3 or ASN.1 module.

* The configuration file parser of the run-time environment handled string values concatenated from two or more fragments incorrectly in sections `[LOGGING]`, `[TESTPORT PARAMETERS]` and `[EXTERNAL COMMANDS]`. In most cases the entire string was simply substituted with the first fragment and the rest was ignored. Such fragmented strings are used mostly in combination with macro substitution when only parts of the string come from macros.

* The Main Controller printed a strange error message complaining about unexpected message STOPPED KILLED when a PTC terminated because of an error while it was executing a blocking TTCN–3 operation. A typical example for this situation is when a PTC is trying to map its own port to a system port, but the operation fails in the test port for some reasons.

* The compiler crashed with a segmentation fault during semantic analysis while checking the definitions of an erroneous group. This could happen if a group contained valid definitions, but the end of the group (i.e. the closing bracket) was missing from the input file. The syntax error related to the faulty group was reported properly during parsing.

* Unsuccessful BER decoding of ASN.1 string types could lead to memory corruption causing segmentation faults in the run-time environment. The problem occurred if the string variable that was passed to the decoder to store the result had a previously assigned value. First the memory buffer carrying the previous value was deallocated, but if the decoding failed the variable was not updated properly. Thus further operations on the variable or the destructor tried to deallocate the same memory area again.

* The run-time environment created wrong BER encoding for negative INTEGER and ENUMERATED values that were smaller than -8388608. In case of such numbers the size of the value part was set to 4 octets correctly, but the encoded value represented a number that was greater than necessary by one (-8388608 instead of -8388609, -8388609 instead of -8388610, and so on). In case of input -8388609 the encoded value was invalid (overlong) according to the rules of CER and DER.

* Matching of TTCN–3 regular expressions did not work on Cello Packet Platform in parallel mode. The routines converting TTCN–3 regular expressions to their POSIX equivalents referred to macros stdin and stdout, which caused restart of the operating system. The problem occurred when matching templates of type charstring containing matching mechanism pattern or using the built-in predefined function `regexp()`. Executable test suites built in single mode were not affected by this fault.

* The following bug fixes have been made on the GUI:

* The GUI no longer tries to create symlinks for non-existing files in the project. This behavior resulted in creating symlinks in the working directory pointing to itself.

* Crash fixed when loading a FileGroup from file when no other FileGroup was present in the project.

[[version-1-6-pl5]]
== Version 1.6.pl5

Released on November 27, 2006.

*New features*

* The meaning of TTCN–3 subtype constraints in nested record of and set of types has been clarified. Formerly the type restrictions were attached canonically to the outermost type, but now they belong to the innermost type embedded in record of or set of construct.

* The TTCN–3 language mode of utility `ctags` has been enhanced. Source line markers in preprocessed TTCN–3 modules are now recognized and interpreted. Recognition of the following TTCN–3 language elements has been corrected or improved: constants, variables, templates, template variables, enumerated types, nested type definitions.

* The subroutine of utility `*ttcn3 logmerge*` that extracts the test component identifier from the name of the log file has been improved. The new algorithm works better when a custom file naming convention is used and the component reference is separated with a dot (.) character rather than a dash (-).

* The `Makefile` generator functionality has been significantly improved and moved from the compiler to a separate utility called `*ttcn3 makefilegen*`. The following changes have been made:

* The program automatically recognizes TTCN–3 include files with suffix `.ttcnin.`

* The detection of file name clashes and filtering of generated files related to TTCN–3 preprocessing and/or central storage has been improved.

* Warnings are displayed if the central storage or preprocessing options are used unnecessarily or the options are not used, but they should be.

* The program detects if the names of input files contain spaces or other special characters that cannot be handled by the make utility.

* The path transformation rules are also applied on the name of the target executable.

* On Windows the `.exe` suffix is appended to the name of the target executable only if the file name does not contain that.

* The compiler and the run-time environment supports the evaluation of some nonstandard TTCN–3 macros. The detailed description of the macros can be found in the Reference Guide.

* Macro substitution modifier hostname was introduced in the run-time configuration files. This modifier allows the substitution of macro values containing a DNS name or IP address into sections `[GROUPS]`, `[COMPONENTS]` and `[MAIN CONTROLLER]`.

* The following enhancements have been made on the GUI:

* Exclude and Include from build functionality has been added to source files included in File Groups.

*Fixed bugs*

* In some cases the GUI did not load the user-defined test sets that were stored in the project.

1640
* The compiler generated wrong (uncompilable) {cpp} code for the location information when the name of the input file contained special characters (like the backslash) that require escaping in {cpp} string literals.
Elemer Lelik's avatar
Elemer Lelik committed
1641
1642
1643
1644
1645
1646
1647

* The compiler aborted with an internal fatal error during semantic analysis if a RAW attribute POINTERTO referred to a non-existent field. The abort occurred after printing the relevant error message.

* The performance of utility `*ttcn3 logformat*` was very poor on log files containing very long lines. It took several minutes even for a powerful processor to format a file containing only a few megabytes of data. The reason was regular expressions that were supposed to match the beginning and end of TTCN–3 test cases were given in an inefficient way so that the parser generated by utility `flex` could not process the input with a linear algorithm. The complete internal structure of `*ttcn3 logformat*` has been redesigned to eliminate the performance critical regular expressions. The block indentation algorithm has been replaced with a more robust one that, for instance, can re-indent previously indented log files.

* The compiled did not issue warnings for some TTCN–3 reserved words that can appear in ASN.1 modules thus making the corresponding ASN.1 value or type field unreachable from TTCN–3 . The values of type verdicttype (like `none` or `error`) and the binary operators of TTCN–3 (like `not4b` or `xor4b`) were not detected and reported by the compiler.

1648
* The compiler crashed with a segmentation fault when generating code for an ASN.1 open type that did not have table constraint. This problem was introduced by a bugfix of the previous release that was about missing {cpp} classes related to open types. Nevertheless, an ASN.1 open type without table constraint is useless in TTCN–3 because there is no way to create templates for it. The compiler now reports warnings when encountering such open types.
Elemer Lelik's avatar
Elemer Lelik committed
1649
1650
1651

* The semantic analyzer of the compiler verified the arguments of built-in TTCN–3 conversion functions int2hex and int2oct incorrectly. In some cases when the arguments were constants and the given value did not fit in the given length the semantic analyzer did not report any error, but the compiler aborted with an internal fatal error during constant folding while doing the conversion.

1652
* The compiler generated incorrect {cpp} code for TTCN–3 for loops if the boolean guard expression was constant false. In this case the entire loop was substituted with an empty {cpp} statement although the initial variable assignment had to be executed exactly once in all cases. The wrong code could cause problems if the initial assignment had side effects (e.g. it called a function or modified a variable defined outside the for loop).
Elemer Lelik's avatar
Elemer Lelik committed
1653
1654
1655
1656
1657
1658
1659

* The compiler and the run-time environment supports the short-circuit evaluation of logical `and` and `or` operations as it is required by the TTCN–3 standard. If the result of the operation can be determined based on the first (left) operand (i.e. the first operand is false in case of and or true in case of or) the second (right) operand will not be evaluated at all. The writer of the TTCN–3 code can exploit this behavior if the right operand may have side-effects or cause a dynamic test case error.

* The compiler reported wrong location information for some TTCN–3 parse errors. For example, when a literal integer value was too large the error message indicating the overflow referred to the previous token of the input rather than the number itself.

* The compiler detects if the same TTCN–3 or ASN.1 input file is passed to it more than once and reports a single, but appropriate error message about this. Formerly the file was parsed and analyzed several times, the same error messages were repeated and only an error message complaining about duplicate module identifiers referred to the real problem.

1660
* The generated {cpp} code suffered aliasing problem in case of some TTCN–3 function and altstep calls. If a component variable was passed as in parameter to a function having runs on clause and the called function modified the same variable the value of the in parameter has also changed. This behavior breaks TTCN–3 semantics since in parameters shall always be passed by value. The code generator has been fixed by adding explicit copy constructor invocations at the calling side when necessary.
Elemer Lelik's avatar
Elemer Lelik committed
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677

* The configuration file handler of the GUI reported syntax error and created syntactically invalid configuration file if a compound module parameter within brackets contained a typed macro reference. The problem was caused by a subroutine of the GUI that performed block auto-indentation on all configuration file entries. The algorithm did not recognize the brackets of the macro reference and inserted whitespace between the "$" and "{" characters.

* The compiler did not export the type descriptors of the embedded TTCN–3 and ASN.1 types to the generated header file. Thus the generated code was uncompilable if the embedded type was referenced from another module using field or array subreferences.

* The compiler performed incomplete semantic analysis on the arguments of built-in operations `ispresent` and `ischosen`. For instance, when the operations were used in the value of a constant the compiler did not report an error if the argument referenced to a template or template variable.

* Built-in operation `ischosen` was not implemented properly in the run-time environment. When the argument was an unbound union value the operation returned false rather than causing a dynamic test case error.

* The macro processor of the run-time configuration files did not allow the substitution of macros with empty values as `bitstring`, `hexstring` or `octetstring` value.

* When a project file was passed to the GUI as command line argument the program did not convert the simple file names or relative pathnames to absolute paths. Thus the same file could appear several times on the list of recently opened projects.

* In some cases the GUI crashed with a segmentation fault when selecting and opening a file from the list of recently used projects. The reason was that the program tried to use a string reference pointing to a value that was already destroyed.

* The compiler checked the actual parameter of a parameterized ASN.1 assignment only when the parameter was referenced through the dummy reference. This allowed syntax and semantic errors in the actual parameters to remain hidden if the dummy reference was not used within the body of the parameterized assignment. The corrected algorithm checks all actual parameters as well as the entire instantiated assignment at the point of instantiation when processing the parameterized reference.

1678
* The generated {cpp} code could contain name clashes between types and values generated at the instantiation of parameterized ASN.1 assignments. The clash could occur, for example, when a parameterized information object assignment had a field setting and a parameter (dummy reference) with identical names (apart from the leading &).
Elemer Lelik's avatar
Elemer Lelik committed
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746

[[version-1-6-pl4]]
== Version 1.6.pl4

Released on July 31, 2006.

*New features*

* The `Makefile` generator of the compiler supports the use of C preprocessor on TTCN–3 code. The TTCN–3 parser of the compiler understands the preprocessor’s line directives thus the error messages refer to the right position in the source code.

* The non-standard TTCN–3 language extension about function, altstep and testcase references and the related operations, such as apply, refers and derefers are now supported.

* The non-standard TTCN–3 language extension about non-mandatory parameters are now supported. It is now possible to assign default settings to formal parameters and omit actual parameters when invoking the respective definition.

* The run-time environment supports the use of UNIX domain sockets for the realization of TTCN–3 port connections. This results in more efficient data transfer on native UNIX platforms compared to the former TCP-based method when both endpoints of the port connection are located on the same computer.

* Test execution is now supported on Cello Packet Platform with OSE Delta operating system.

* The memory requirement of the run-time environment has been improved by a few percents. For instance, in older versions every string value allocated 3 bytes more than it is necessary.

* The execution time as well as the memory usage of the compiler has been improved by a few percents. The generic containers of the abstract syntax tree have been optimized.

* In parallel mode it is allowed to connect a new Host Controller to the Main Controller while a test case is running. The newly connected HC gets the configuration information immediately and takes part in load balancing as soon as possible.

* The Main Controller supports the relocation of a newly created PTC to another host if it is impossible to create a new process on the host that was chosen initially. If the Host Controller cannot create a new process the MC will exclude the host from load balancing until it reports that overload has ceased.

* The logging routines of the run-time environment support the handling of several log events in a stack-based concept. It is allowed to call TTCN Logger:: `begin event()`, `log event()` and `end event()` in the middle of another event. This allows the use of `TTCN–3 log()` statements in recursive contexts (e.g. when the return value of a function is being logged and the function itself also contains `log()` statements).

* During load tests it often happens that two test components continuously send data to each other through connected ports. Earlier versions of the run-time environment used blocking send operations on the underlying TCP connections, which could lead to deadlocks if all network buffers were full in both directions. Starting from this version non-blocking send operations are used on port connections and when sending would block the test component tries to increase the size of outgoing network buffer if this is supported and allowed by the operating system. If the buffer cannot be enlarged any further the send operation will block and also try to handle incoming messages. In this case a warning message indicates the unusual operation of the run-time environment (i.e. new incoming messages might appear in the port queues while only sending is performed). +

NOTE: This improvement prevents the test system from deadlocks in many cases, but there is no warranty that the run-time environment can cope with all possible situations (for example, infinite port queues exist only in theory). The ultimate solution is to restrict the amount of outstanding data on port the connections by well designed flow-control algorithms in the TTCN–3 code (e.g. by introducing an application level sliding-window protocol).

* The compiler’s output generation algorithm has been improved. In order to perform selective updates the compiler first writes the generated code into a temporary file and updates the final target only if the contents of the existing file differs from the newly generated one. In earlier versions the temporary files were always created even if the real target files did not exist. Now the output is written directly to the target file if a previous version does not exist, which can result in significant speedup in the compiler’s operation when building large projects from scratch.

* The compiler supports error recovery in the RAW and TEXT encoding attributes of TTCN–3 types. Formerly a single syntax error in the attribute text caused the compiler to stop immediately.

* Macro substitution is now supported in section `[MAIN CONTROLLER]` of the configuration file in both command-line and GUI modes.

* Basic arithmetic operations and concatenation of character string values are now supported in the run-time configuration file. This allows the more flexible use of macros since a module parameter or a configuration option can be derived from several macros and/or constant values.

* The TTCN–3 parser of the compiler allows in-line compound values in the operands of expressions. +

NOTE: Compound values can only be used with comparison operators (i.e `==` or `!=`) and the other operand has to be a referenced value.

* Metacharacter `%c`, which denotes the name of the current testcase, is now supported when specifying the names of the log files in section `[LOGGING]` of the configuration file.

* The run-time environment knows about the names of TTCN–3 timers. Log entries and error messages related to timers now contain the name of the corresponding timer, which makes the analysis of logs easier.

* The following enhancements have been made on the GUI:

* Execution Window: When configuring the host controllers with ’Detailed actions’ switched on, the configuration file to use can be chosen from a list.

* Project Window / File tree: File Groups section added.

*Fixed bugs*

* The behavior of the run-time environment could be undefined if the left operand of TTCN–3 concatenation operator (`&`) was a bitstring element (containing a single bit) and the right operand was a bitstring value. If the right operand was long enough the operation could lead to segmentation fault because a programming mistake allowed over-indexing in memory.

* The pre-defined functions `bit2int`, `hex2int` and `oct2int` refused the conversion with a dynamic test-case error if their argument contained more bits than the integer representation of the given platform. Now the conversion is possible if the argument is longer than this limit, but after cutting the leading zero bits, hex digits or octets the result can be represented as a non-negative number in the integer type. On the other hand, the conversion was incorrectly possible if the input had the same size as the integer type, but the result was a negative number. Both the compiler and run-time versions of these functions were affected by this fault.

* The compiler reported an inappropriate warning message when checking a value or template of an empty record or set type. The message stated that all elements were not used symbols (i.e. -) although the value or template did not contain any elements. +

NOTE: The only possible value of these types is _{}_.

* The error messages of the compiler contained incomplete or missing location and context information hierarchy if there was an error deeply within a complex TTCN–3 expression.

* The Main Controller stopped in a deadlock in batch mode if the MTC and all alive HCs terminated at the same time and closed their control connections unexpectedly.

1747
* Empty character strings in TTCN–3 pattern templates were not handled properly. The compiler accepted empty strings after the pattern keyword, but generated faulty (uncompilable) {cpp} code. Moreover, the run-time environment reported dynamic test case error if the pattern was empty (e.g. after variable substitution). Of course, empty charstring patterns are allowed and they match the empty string values only.
Elemer Lelik's avatar
Elemer Lelik committed
1748
1749
1750
1751
1752

* The TTCN–3 parser of the compiler rejected array index sub-references in type references. That is why a nested unnamed type of a record of type could not be addressed. +

NOTE: The array indices in type references are handled in a special way in the compiler: it is verified that the value in square brackets should be of type integer, but the number itself is not used for anything.

1753
* The compiler generated wrong (uncompilable) {cpp} code for ASN.1 open types in some cases. The {cpp} equivalents of some types and values were missing if an unnamed information object set was used in the open type’s table constraint. This was the case, for instance, if the open type was embedded into a parameterized type assignment and the object set was defined in-line in the actual parameter list of the type reference.
Elemer Lelik's avatar
Elemer Lelik committed
1754

1755
* Incremental compilation of ASN.1 modules did not work properly if the instantiation of some parameterized type assignments changed since the last full re-compilation of all modules. Changing the order of files in the compiler’s command line could cause similar problems. Module-based incremental compilation uses the concept that the {cpp} equivalent of a module shall only depend on the module itself and the imported modules. Importing modules that use some definitions from the module must not influence the generated code. The {cpp} equivalents of parameterized assignments are generated when the assignment is instantiated by a parameterized reference (because only these instances can be visible from TTCN–3 ). The instances are created in the module where the parameterized reference is because the actual parameters might be visible only from that module. Different instantiations of the same parameterized assignment are identified by instance counters. Earlier versions of the compiler used one instance counter for each parameterized assignment. This can cause problems when there is a parameterized assignment in module A and it is instantiated from B and C. If the number of instantiations in B changes this would change the instance counters of C. Thus the generated files of C became outdated although C does not import from B. Starting from this version the instance counters are associated with target modules. In the above example the parameterized assignment in A has two counters: one for B and another for C. This change required a new naming convention for the {cpp} classes of instantiated types: the identifier of the target module became part of the name, which resulted in longer {cpp} identifiers.
Elemer Lelik's avatar
Elemer Lelik committed
1756

1757
* The compiler assigned wrong identifiers to some ASN.1 open type members. Open types are mapped to implicit CHOICE types and the alternatives are the distinct types from the table constraint’s object set. The alternative identifiers of the CHOICE are derived from each type’s name by changing the first letter (which must always be a capital letter) to lower case. This mapping of names did not work properly if the elements of the object set were the instances of a parameterized information object assignment. For instance, different types got the same identifier (and therefore the generated {cpp} code was invalid) if the respective object field was a dummy reference pointing to the object’s formal parameter. When constructing open types the compiler generates a warning message if a member type has a complicated constructed name and thus the alternative will get a strange identifier. These warnings were missing too from the instances of parameterized types.
Elemer Lelik's avatar
Elemer Lelik committed
1758
1759
1760
1761
1762
1763
1764
1765
1766

* The semantic analyzer of the compiler did not accept value (character) range matching mechanisms in templates of type universal charstring.

* Values of type charstring that were created by indexing a single-character element of another charstring value had incorrect internal representation in the run-time environment. The run-time representation of charstring values contains a length indicator and a terminating zero byte is also appended at the end of the string. However, the indexing operator set only the length indicator in the result so the builtin functions that relied on the terminating byte (e.g. str2int) worked incorrectly.

* The compiler did not handle the unterminated TTCN–3 comments properly at the end of file. Unterminated line comments (beginning with "//" and when the file did not end with a newline character) were accepted without any error message. Moreover, an unterminated block comment (beginning with "/*") could confuse the compiler so that it was unable to parse further files.

* The compiler aborted with an internal fatal error when detecting an erroneous reference in the argument of built-in operations `ispresent` or `ischosen`. The proper error message was displayed before the abort.

1767
* The compiler generated wrong {cpp} code (which worked incorrectly) for TTCN–3 function calls in very rare cases. The aliasing problem occurred if the same variable was passed to a function as both in and `inout` parameters. When the function has updated its `inout` parameter (i.e. the variable of the caller) the value of the in parameter has been changed although it should have been constant throughout the entire function call.
Elemer Lelik's avatar
Elemer Lelik committed
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813

* The compiler aborted with an internal fatal error during the comparison of constant values of TTCN–3 type objid and its ASN.1 equivalents (i.e. OBJECT IDENTIFIER and RELATIVE-OID). This could occur, for instance, while the compiler was checking the component relation constraints of some ASN.1 protocol modules.

* The compiler’s semantic analyzer rejected the return statements within the body of altstep definitions although the latest version of the TTCN–3 standard allows them.

* Checking of built-in operation `valueof` was implemented incorrectly in the compiler’s semantic analyzer. For instance, the compiler did not report error if the argument of `valueof` was of an incompatible structured type. Another bug in the algorithm caused segmentation fault during code generation if the argument was an in-line modified template.

* The compiler’s semantic analyzer verified the uniqueness of field names in TTCN–3 record, set and union types and the correctness of embedded types in a single step. This strategy resulted in false error messages as well as memory leaks if a type was part of multiple recursion loops and had RAW encoding attributes that referred to its recursive fields, such as `LENGTHTO` or `CROSSTAG`. The algorithm has been restructured into two distinct steps so that the embedded types are not analyzed until the field names are completely verified.

* The RAWencoder of the run-time environment could crash with a segmentation fault while encoding a union value with TAG attribute. This was the case if the field that was referred by TAG (which is used to select the right alternative during decoding) had an invalid value. The situation was similar if more than one values were listed for the current alternative and the value to be encoded did not contain the first one from the list.

* The compiler could report false errors or abort with internal fatal error if the length restriction of a TTCN–3 template contained an arithmetical expression of type integer rather than a literal value.

* The ASN.1 parser of the compiler classified the information object assignments incorrectly as value assignments if the governor information object class was parameterized. Due to the false recognition the semantic analyzer reported inappropriate error messages and crashed with a segmentation fault.

* The compiler could crash with a segmentation fault during semantic analysis when a parameterized ASN.1 assignment was instantiated and its right-hand side contained an in-line information object set definition (e.g. in a table or component relation constraint).

* The following bug fixes have been made on the GUI:

* Project Window / File tree: The GUI crashed if included projects contained test sets. Now they are displayed correctly, and are offered for execution in the Execution window.

* Execution Window: Log lines containing only a number are aligned to the left of the table cell instead of aligning to right.

* Project Window / File tree: Fixes in included project handling. There is no more warning about read-only project file for included projects.

* Project Window / `Makefile` generation: Sources under "Misc Files" are not included in the `Makefile`. They get automatically" Excluded from build" when adding them to the project.

* Process Monitor: Normal text color is not changed after clicking on highlighted text.

* Execute Dialog: Controls, Test Cases and Test Sets are placed in right order in the list.

[[version-1-6-pl3]]
== Version 1.6.pl3

Released on December 16, 2005.

*New features*

* Arrays of TTCN–3 language are now fully supported. This includes multidimensional arrays, arrays within type definitions and index ranges with lower and upper bounds. Index values in array references are verified against the array bounds both in the compiler (as long as the index value is constant) and in the run-time environment. In case of index overflows or underflows a proper run-time error message is generated instead of the unpredictable behavior of former versions.

* The template matching mechanisms subset and permutation are now fully supported.

* Semantic analysis of TTCN–3 group names has been implemented.

* TTCN–3 with attributes that belong to modules or group definitions are now processed and propagated to the embedded definitions. Consistency checking of attributes and attribute qualifiers has been improved.

1814
* The compiler supports generation of `Makefiles` to be used with central storage of precompiled files. Administrators of larger projects can collect and compile the common TTCN–3 and ASN.1 modules that change rarely (type definitions, test ports, etc.) in a central directory. Test developers can build their projects without re-compiling the common modules by taking the pre-compiled object files and {cpp} header files from the central storage. Usage of this feature can save compilation time as well as disk space for the individual developers.
Elemer Lelik's avatar
Elemer Lelik committed
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855

* The configuration file of the run-time environment has been enhanced. Two new sections (`[INCLUDE]` and `[DEFINE]`) have been introduced. This allows modular configuration information spanning over multiple files and usage of macros and environment variables within the configuration files.

* Built-in TTCN–3 operations `ispresent`, `ischosen`, `lengthof` and `sizeof` are now applicable to templates and template variables in addition to values (constants, variables, etc.).

* The RAW encoder/decoder supports forward references in `CROSSTAG` attributes. It is allowed that the decoding of an union field depends on another field that is defined later in the same record if the union field is mandatory and all embedded alternative types have the same, fixed size. During decoding such union fields are processed out of order. In the first round the field is simply skipped, it is processed only when the field that determines which alternative to choose is successfully decoded.

* The run-time environment and the MC supports the killing of the MTC process if it is not responding because it is stuck in an infinite loop. Formerly an unresponsive MTC could cause deadlock in the whole test system. The termination of MTC can be initiated from a PTC using operation `mtc.stop` or from the user interface by issuing a `stop` command or pressing the *Stop* button. The MTC process is killed only if it does not respond to the stop request before the guard timer expires.

* The IP addresses used for the control connections between the Main Controller and Host Controllers and test components are now configurable. These options are useful when testing is performed on multi-homed hosts (i.e. computers with multiple network interfaces and/or IP addresses). In case of MC the address of the TCP server can be restricted using a new option in the configuration file. On the HC side the client IP address can be set using a command line switch.

* The expect script `*ttcn3 start*` accepts absolute or relative path names as the name of the ETS. If the configuration file is not specified explicitly in the command line it is searched in the same directory as the ETS is in.

* The following enhancements have been made on the GUI:

* Configuration Editor: Updated to handle the new sections (`[INCLUDE]` and `[DEFINE]`).

* Project window: Subprojects can be added to the main project. `Makefile` generation is updated to generate `Makefile` supporting the central storage.

* Project window: Project tree now remembers the opened and closed state of the main types.

* Project window: When adding a file to the project with a name which already existed within the project’s files, replacing the old file with the added one is offered.

* GUI Preferences: The line number switch for the external editor can be configured.

* Process monitor: Highlighting of the source code file paths with line numbers, errors, warnings and identifiers added. The source code with the line number can be clicked, and if configured well in the preferences, the external editor will be opened at that line.

* Project Properties: Added setting of whether to create symlinks with absolute or relative target path.

* Project Properties: Added setting of whether to use absolute paths in the generated `Makefile`.

* Execution window: *Follow last log line* checkbox added to the toolbar to set the log area to scroll to the last added line or not.

* Execution window: The items in the Execute Dialog are not sorted alphabetically by default. The order of the controls and test cases will be the order they were returned by the test case collection (the order they were written in the source modules).

* GUI Preferences: %active config path added to the selectable GUI variables for use in the User Menus.

* The Log Browser supports searching of strings within the event texts.

*Fixed bugs*

1856
* Templates with length restrictions produced strange printout in the run-time logs due to a missing break in a {cpp} switch-case statement.
Elemer Lelik's avatar
Elemer Lelik committed
1857
1858
1859

* The run-time location information of else if statements pointed to the wrong line of the TTCN–3 code. For example, if an error occurred in the boolean expression of an else if statement the dynamic test case error message of the log file contained the line number of the first if statement. This made difficult to find the reason of the error since the first boolean expression, which the error message referred to, was correct.

1860
* The compiler generated faulty {cpp} code if the last statement of a TTCN–3 statement block was a select-case statement. The {cpp} compiler complained about that the last label of the block was not followed by a statement. The syntaxerror was corrected by adding an empty {cpp} statement (i.e. a semi-colon) after the corresponding label.
Elemer Lelik's avatar
Elemer Lelik committed
1861

1862
* The compiler crashed with a segmentation fault during code generation if the boolean expression of a TTCN–3 if, for or while statement contained an in-line compound expression that could not be mapped directly to a {cpp} expression.
Elemer Lelik's avatar
Elemer Lelik committed
1863
1864
1865

* If the actual value for a module parameter of a record of or set of type contained fewer elements in the configuration file than the default value in the TTCN–3 module then the surplus elements of the default value remained present after processing the configuration file.

1866
* The compiler could produce a segmentation fault when generating the {cpp} structures for describing TEXT encoding of enumerated types. The reason was that the code generation subroutine addressed internal data structures in a wrong manner.
Elemer Lelik's avatar
Elemer Lelik committed
1867
1868
1869
1870
1871

* The expect script `*ttcn3 start*` detects if the configuration file instructs the MC to run in batch mode. Instead of causing a deadlock the script terminates with a proper error message.

* The compiler aborted with an internal fatal error if a TTCN–3 template reference tried to address a sub-field or element of a template (or template field) containing a generic wildcard like ? or *. Now a proper error message is printed in these circumstances.

1872
* The value comparison algorithm for set of types was not implemented in the compiler. These functions are applied during constant folding (i.e. when all operands of a TTCN–3 expression are available at compilation time) to substitute the expression with its result in the generated {cpp} code. In case of set of values the comparison algorithm of record of types was applied, which could give incorrect result because it considered the order of elements.
Elemer Lelik's avatar
Elemer Lelik committed
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895

* The TTCN–3 language mode of program `ctags` did not handle the string literals properly. If a TTCN–3 string constant contained a special character like _{_ or _}_ `ctags` got confused and ignored the definitions in the rest of the file. Moreover, the program failed to parse character string patterns within templates.

* The run-time environment did not specify the client IP address for the control connections towards the `MC`, thus it was chosen by the kernel independently for every connection. On some multi-homed Sun Grid environments it could happen that a test component got a different local IP address from the kernel than the `HC` (i.e. its parent process). In this case the `MC` refused the component’s control connection and the respective create operation failed with a dynamic test case error. In the new version only the `HC`s can get automatically assigned IP addresses (unless the local address is explicitly given in the command line). The test components (child processes) always assign the HC’s local IP address explicitly before establishing their control connections.

* The RAW decoder of the run-time environment contained a memory leak. When the decoding of an enumerated value was unsuccessful a memory block containing a temporary string was not deallocated. This could lead to significant memory growth in case of load testing, especially when the types used the TAG attribute, the decoding of which is implemented using backtracking.

* The run-time environment caused a dynamic test case error when an optional record or set field containing omit value was compared with a mandatory field or a simple value. The false error message complained about unbound operand of comparison. Now those operations return the appropriate boolean result: false in case of operator `==` and true in case of `! =`.

* The dynamically linked version of the TTCN–3 Base Library (i.e. libttcn3-dynamic.so and libttcn3-parallel-dynamic.so) did not contain all functions that are necessary for building the executable. If those libraries were used the linker complained about a lot of unresolved function references. Thus only the statically linked versions of the Base Library (i.e. `libttcn3.a` and `libttcn3-parallel.a`) were usable. The reason was a mistake in the built script (the script did not add some object files to the dynamic libraries).

* The compiler aborted with an internal fatal error if it encountered non-ASCII characters (i.e. character codes above 127) in the argument of predefined function `char2oct()`.

* The expect script `*ttcn3 start*` could hang in a deadlock after issuing the `emtc` command. The reason was that the expected output lines of the Main Controller (MC) came in the wrong order due to a race condition within the MC. To avoid such problems in the future both the script has been enhanced and the race condition has been eliminated.

* The utility `*ttcn3 logformat*` did not separate the log entries belonging to different test cases (using the `-s` option) when the timestamps contained the date (i.e. option `TimeStampFormat` was set to `DateTime` in section `[LOGGING]` of the configuration file). In this case all entries were dumped to standard output. This was because a incorrect regular expression was specified in the parser for those timestamps.

* The utility `*ttcn3 logmerge*` did not detect or handle write errors (e.g. when the disk became full the user was not notified that the output file is incomplete). Now the utility reports the appropriate error message and terminates immediately when it encounters any error related to file operations. Moreover, it was not handled properly when the limit of simultaneously open files was reached on Solaris 2.6. In such situations the program got into an infinite loop of printing error messages.

* The program routine that is responsible for processing TTCN–3 character patterns contained a memory leak. Although this fault affected the compiler as well, it could cause serious problems in the run-time environment during long-duration performance tests. The memory usage of TTCN–3 test components increased continuously if they used charstring templates containing pattern matching mechanisms or the predefined function `regexp()`.

* Utility `*ttcn3 logmerge*` could cause segmentation fault if one of its arguments was a path name containing . or .., but its file name part did not contain dash (i.e. -) character.

1896
* The compiler generated invalid {cpp} code if the first operand of predefined function `substr` was a charstring element. The {cpp} compiler complained about an ambiguous function overload.
Elemer Lelik's avatar
Elemer Lelik committed
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908

* The following bug fixes have been made on the GUI:

* GUI Preferences: Successful saving of the settings is checked, and an error dialog is shown when it fails.

[[version-1-6-pl2]]
== Version 1.6.pl2

Released on August 1, 2005.

*New features*

1909
* {cpp} code generation for TTCN–3 interleave statements is now supported.
Elemer Lelik's avatar
Elemer Lelik committed
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932

* The compiler reports a warning if an ASN.1 identifier is a TTCN–3 keyword so it is unreachable from TTCN–3 . The warning is generated only if the ASN.1 identifier should be visible from TTCN–3 (e.g. there is no warning if a named bit or an information object is identified with a TTCN–3 keyword). The names of TTCN–3 predefined functions are also considered to be keywords.

* The following enhancements have been made on the GUI:

* Project window: When creating new configuration file, the default assignments are commented.

* Project window: When creating new TTCN-3 or ASN.1 files, the file and module names are checked against basic mistakes.

*Fixed bugs*

* The Main Controller updated its internal state table incorrectly when an idle nonalive type PTC was stopped explicitly by another test component. The PTC was instructed properly to terminate, but MC reported unexpected events when the PTC finished. As a consequence of this MC assigned error verdict to the corresponding PTC at the end of the testcase regardless its real final verdict.

* The command line version of the Main Controller (i.e. `mctr cli`) stuck in a deadlock if the MTC terminated unexpectedly in batch mode. This could happen, for example, if a faulty Test Port caused the MTC to crash with a segmentation fault. Now this situation is handled explicitly by the MC, which reports an error and terminates with unsuccessful exit status in this case. The same problem was also present in the expect script `*ttcn3 start*`, which invokes `mctr cli` in interactive mode. The script was fixed, too.

* The Log Browser displayed those log entries incorrectly that consisted of a timestamp and an integer number. Such entry can be produced, for example, by passing an integer value to the TTCN–3 `log()` statement. When seeing this line the Log Browser got confused and recognized the integer number as a component reference and considered the entire next log entry (line) as the text of this event.
*
The compiler reported strange error messages on valid TTCN–3 input if an encoding token of a TEXT attribute contained one of the following characters: #, ], _}_ and a decoding token was not specified for the same attribute. When the decoding token is omitted the compiler derives it from the encoding token automatically. Since the encoding token is a simple charstring value, but the decoding token is a TTCN–3 pattern the characters that have special meaning in patterns have to be escaped. The above three characters, however, were not escaped during the transformation.

* The BER decoder for one-octet character strings (i.e. ASN.1 character string types that are mapped to charstring in TTCN–3 ) created incorrect string values. In the internal string representation the length and the content characters were set properly, but the terminating NUL character (zero byte) was missing at the end of the decoded string. In most cases the fault remained invisible because the majority of built-in string operations use the length field. However, the predefined function `str2int` uses the NUL terminated string without the length, which caused undefined behavior if its input came from BER decoding.

* It was impossible to specify literal charstring values in RAW encoding attributes of TTCN–3 types. Since the coding with attribute is delimited with quotation mark characters the beginning and end of the embedded string has to be escaped (i.e. the quotation mark character shall be preceded with a backslash or a double quotation mark character shall be used). However, the attribute parser of the compiler used a wrong regular expression, it expected a single quotation mark character as delimiters in charstring literals.

1933
* The code generator of the RAW enc/dec did not prefix the enumerated values if the `-E` (enum-hack) compiler switch was turned on. Thus the generated {cpp} code did not compile in this case.
Elemer Lelik's avatar
Elemer Lelik committed
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009

* The documentation of RAW attribute `PRESENCE` contained a mistake in syntax description. The attribute parser of the compiler required a pair of brackets for multiple values, but the documentation does not. Now the parser accepts both syntax variants to preserve backward compatibility.

* The RAW encoder encoded the empty charstring values incorrectly. The result of encoding was nothing (empty string) even if the FIELDLENGTH attribute was set to a positive number.

* The following bug fixes have been made on the GUI:

* Execution window: GUI hung in a deadlock when displaying errors or warnings during test execution.

* Project window / process output on Cygwin: endless loop avoided on Cygwin when executing a process. +

NOTE: Cygwin is not officially supported by TCC.

[[version-1-6-pl1]]
== Version 1.6.pl1

Released on June 30, 2005.

*New features*

* The TTCN–3 parser of the compiler works based on the final BNF of version 3.1.1 of the Core Language standard. This implies the following minor additions:

* Nested (unnamed) TTCN–3 type definitions can now be used.

* The log statement accepts template instances (including inline and inline modified templates) in addition to values and template references.

* The halt port operation is now supported.

* The TTCN–3 select-case statement is now supported.

* Test case static test configurations, that is, alive TTCN–3 test components and the related operations are now supported. The following new component operations have been added: create alive, kill, killed, alive. The meaning of the following existing component operations has been extended: stop, done, running.

* Error recovery in the TTCN–3 parser has been significantly improved.

* The following enhancements have been made on the GUI:

* Project window: added toolbar icon (hotkey: F9) for executing the `[EXECUTE]` section of the config file.

* Project window: toolbar icons (and separators) can be sorted by adding @place number to the end of their name, i.e. `MAINTOOLBAR_>_Make -j2@5`.

* Project window: file tree accepts the *<Del>* key.

* Project window: hotkeys: CTRL+C stops current process execution, CTRL+L clears current process window, CTRL+W closes current process monitor if it is enabled.

* Project window: executable is offered to be removed when changing the Build/Execution mode.

* Project window: symlinks are created as relative symlinks instead of absolute.

* Project window: log files are refreshed right after loading the project.

* Project window / Process monitor: performance improved.

* Config file editor: save compound values formatted.

* Execution window: improved stability and memory consumption on high load.

* Execution window: button sizes are the same when switching to Detailed.

* Execution window: test execution does not need any config file.

* Execution window: waits until the specified number of HCs (NumHCs in the config file) connect before starting the test execution.

* Execution window: state strings are the same as used in the CLI version.

* Execution window: removes the temporary config file from /tmp when finished.

* Execution window: added timed execution; the start date/time can be set before starting the test in the test case selection dialog.

* Execution window: double click is accepted in the test case selection dialog.

* Execution window: empty selection is not accepted.

*Fixed bugs*

* The compiler aborted with an internal fatal error when checking a TTCN–3 expression (or sub-expression) if all operands of an arithmetic or logical operation were available at compilation timefootnote:[The operands were literal values or references pointing to constants.] and one of the operands was a referenced value pointing to a TTCN–3 constant of type float or ASN.1 value of type REAL.

2010
* The generated {cpp} code was uncompilable if the name of an ASN.1 built-in string type (e.g. UTF8String) was used as identifier in a TTCN–3 module or the name of a TTCN–3 built-in conversion function (e.g. bit2int) was used as ASN.1 identifier. Now the compiler appends a single underscore character to the {cpp} equivalents of these identifiers to avoid name clashes with the definitions of the Base Library.
Elemer Lelik's avatar
Elemer Lelik committed
2011

2012
* The compiler caused segmentation fault during semantic analysis if the type of a constant or module parameter was erroneous (e.g. the referenced type was not imported) and the value of the constant or the default value of the module parameter contained an embedded record or set value (i.e. a value with TTCN–3 assignment notation). The problem occurred after reporting the relevant error message and only if when {cpp} code generation was requested (i.e. the command line switch `-s` was not used).
Elemer Lelik's avatar
Elemer Lelik committed
2013
2014
2015
2016
2017
2018
2019

* The GUI crashed at startup with segmentation fault if the environment variable TTCN3 DIR was not set or the configuration files and images were not found under `$TTCN3 DIR/etc/gui`.

* The compiler analyzed only the top-level expressions in the optional arguments of TTCN–3 `create` operation, that is, recursive checks were not performed on the embedded sub-expressions. Because of this some kinds of errors were not detected and the compiler could abort with internal fatal error during code generation even on valid input (e.g. when a sub-expression contained a simple reference pointing to a variable).

* The semantic analysis did not detect when a variable defined in the header of a TTCN–3 for statement shadowed a definition in an outer scope unit with the same identifier.

2020
* The compiler generated invalid code if the argument of a TTCN–3 `send` operation referred to an optional field of a record or set value (constant, variable, module parameter, etc.). The {cpp} compiler complained about ambiguous overload of a member function in the port class.
Elemer Lelik's avatar
Elemer Lelik committed
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033

* The Main Controller caused segmentation fault in both command-line and GUI modes if the `stop` command was issued while a control part was running and no testcase was executed before.

* In parallel mode the MTC crashed with internal error if a test case was executed after stopping test execution from MC. When the `stop` command of MC interrupted the test execution the actual test case was not terminated properly and MTC remained in an inconsistent state.

* The compiler rejected valid TTCN–3 input if one operand of the comparison operator was a reference pointing to an imported (constant or module parameter) definition and the other operand was an enumerated value. The error message complained about that the compiler was unable to determine the type of operands in the expression.

* The MC reported internal error (unexpected STOPPED message) when a TTCN–3 map operation failed because the Test Port called TTCN error. This error situation is now handled properly.

* The compiler did not allow to assign omit value from an optional field of a TTCN–3 constant to a template variable. The reason was a mistake in the a semantic analyzer routine because it did not propagate an option recursively.

* The semantic analyzer of the compiler reported wrong circular recursion error message if a template reference in a function or testcase contained an array sub-reference the index of which was not constant. For example, this was the case when a for loop iterated through the elements of a record of template or template variable.

2034
* The compiler accepted any kinds of expressions (not only the boolean ones) in if, for, while and do-while statements because of a programming mistake in the semantic analyzer. Moreover, in most cases the generated {cpp} code was compilable (thus the problem remained hidden) if the type of the expression was a built-in TTCN–3 type (e.g. charstring).
Elemer Lelik's avatar
Elemer Lelik committed
2035

2036
* The compiler generated wrong (uncompilable) {cpp} code if the boolean expression of a if, for, while or do-while statement referred to an optional boolean field of a record or set value.
Elemer Lelik's avatar
Elemer Lelik committed
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058

* The semantic analyzer routine of the compiler that checks the length restriction of templates contained several bugs. In certain cases this could cause segmentation faults or aborts in the compiler or the acceptance of invalid inputs. For example, the bugs could be triggered with the following constructs: length ranges with infinity as upper limit, length restrictions for the universal charstring type, length restrictions combined with specific string values.

* The run-time environment did not pass the test port parameters to the respectivetest port objects if the parameter was assigned to named test components. One part of parameter processing routines that handled named test components was inactive due to a programming mistake.

* The run-time environment produced a misleading warning message if an expired TTCN–3 timer was re-started. The message complained about re-starting a running timer although the built-in running operation returns false on expired timers.

* The semantic analyzer of the compiler was unable to determine the type of string patterns in receiving port operations if the corresponding port type had more than one incoming message types. The statement was accepted only if the explicit type specification was present before the pattern (e.g. `p.receive(bitstring:'1?0'B)`;) although the type of the pattern is unambiguous.

* The GUI did not pass the configuration option `KillTimer` to the Main Controller. The default value was always used even if it was overridden in the configuration file.

* In the run-time environment, after invoking the `TTCN EncDec::set error behavior()` function with ET ALL option, the `TTCN EncDec::get last error type()` returned a wrong result unless you cleared it with TTCN `EncDec::clear error()`.

[[version-1-6-pl0]]
== Version 1.6.pl0

Released on April 1, 2005.

*New features*

* The compiler supports semantic checking for the dynamic parts of TTCN–3 modules. This means that TTCN–3 modules are entirely covered with semantic analysis.

2059
* The compiler generates the entire {cpp} code from the output of semantic analysis, the so-called Abstract Syntax Tree (AST).
Elemer Lelik's avatar
Elemer Lelik committed
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094

* The TTCN–3 parser of the compiler supports error recovery, that is, it does not stop when a syntax error is detected, but it tries to read the further parts of the input and perform semantic analysis as well. However, in some cases it is not possible or worth-while to recover from a syntax error.

* The text encoding has been introduced.

* New RAW encoding attribute `REPEATABLE` has been added and the meaning of the `PRESENCE` attribute has been extended.

* The `AssignmentList` notation also can be used in the parameter redirect of `getcall` and `getreply` operations.

* Non-printable control characters of charstring values are printed using C escape sequences or quadruple notation into the log files. The raw format of earlier versions could disturb the log processing utilities.

* In addition to the quadruple notation all escape sequences that are available in the C language are accepted for specifying non-printable characters of charstring and universal charstring values in the run-time configuration file.

* The order of steps that are performed when deactivating a TTCN–3 port at component termination have been changed. Now the existing connections and mappings are shut down first and after that the port is stopped and its queue is cleared. In some Test Ports it can happen that the user `unmap` function tries to add a new incoming message into the port queue when destroying the mapping. In former versions this could cause dynamic test case error because the port was already in stopped state while user `unmap` was running. Now the incoming message is accepted and the port is stopped only after user `unmap` is completed.

* As a non-standard extension the compiler and the run-time environment supports the assignment of names to the test components in create operations. The location of the new component can also be specified at creation, which is useful in distributed test environments.

* Script `*ttcn3 start*` has been enhanced. It supports configuration files that are named differently than the ETS and the execution of multiple test cases given in command line.

* The number of how many times the selected test(s) should run can be set on the GUI when selecting which test to run.

* Input field added to the GUI main window. It is enabled when a process runs. Any input entered here is sent to the process as user input.

* The GUI does not allow the creation or saving of empty test sets.

* The GUI asks whether to recreate symlinks and recreate the `Makefile` if appropriate changes are made on the project’s properties.

* If creating new file through the GUI, and not specifying file extension in the file name selection dialog, the first extension listed in extensions for that type will be appended to the given file name.

*Fixed bugs*

* The compiler aborted with an internal fatal error during code generation if an ASN.1 value assignment contained a `ValueFromObject` reference.

* In some cases the compiler aborted with an internal fatal error when checking modified templates for record of or set of types. This was the case, for instance, if the base template contained a generic wildcard like ? or *.

2095
* The compiler generated invalid (uncompilable) {cpp} code for `getcall` operations if the corresponding signature was imported from another module. This was because the default arguments of the {cpp} function that handles `param` redirects for the respective signature were generated into the source file instead of the header file and thus remained invisible for other modules.
Elemer Lelik's avatar
Elemer Lelik committed
2096
2097
2098
2099
2100
2101
2102
2103
2104

* The code generator of the compiler ignored the `NotUsedSymbol` characters in `param` redirect of `getcall` and `getreply` operations if the `VariableList` notation was used. Thus the run-time environment assigned the wrong parameters to the given variables.

* The compiler ignored and did not check the value list subtype constraints for TTCN–3 union types.

* The compiler aborted with an internal fatal error when the `-P` (top-level PDU) command-line switch was used. This was because the switch `-P` disabled the semantic checking of ASN.1 modules including their import lists. But when the given top-level PDU tried to refer to an imported symbol the symbol table for imported symbols was uninitialized.

* The compiler rejected the `call` operations that did not have response and exception handling part with an error message even if the corresponding signature was a nonblocking one (i.e. it was defined with the `noblock` keyword).

2105
* The compiler generated invalid (uncompilable) {cpp} code for those in-line signature templates the signature of which had no parameters.
Elemer Lelik's avatar
Elemer Lelik committed
2106

2107
* The compiler did not generate the {cpp} equivalents of some data types thus the generated code was uncompilable because of missing classes if an ASN.1 PDU type was defined using an object set, which was imported from another ASN.1 module.
Elemer Lelik's avatar
Elemer Lelik committed
2108
2109
2110
2111
2112

* All generated header files included `version.h` from the Base Library, which made it impossible to use the precompiled headers created by GCC 3.4 or above. The above file contains some preprocessor statements, which disable the processing of existing precompiled headers in further `#include` directives.

* The compiler did not accept the `NotUsedSymbol` in the default duration of timer arrays. The symbol means that the corresponding array element shall have no default duration.

2113
* The compiler might generate invalid (uncompilable) code for the TTCN–3 functions that had signature template parameters. The {cpp} compiler complained about missing encode text and decode text functions, which are used when the corresponding function is being started as a PTC behavior.
Elemer Lelik's avatar
Elemer Lelik committed
2114
2115
2116

* The compiler did not recognize properly the default syntax for ASN.1 objects. If an object class did not have user defined syntax the compiler rejected the valid object definitions with strange parse error messages.

2117
* The semantic analyzer did not detect errors in procedure based port types. For example, a reference to a non-existent signature in the incoming or outgoing list resulted in an erroneous (uncompilable) output {cpp} code.
Elemer Lelik's avatar
Elemer Lelik committed
2118
2119
2120
2121
2122
2123
2124
2125
2126

* Our run-time environment implements the TTCN–3 entity that runs the control part and the MTC in the same process. The lists of active timers and defaults were not separated between the two entities thus the testcase could access and modify the control part timers and defaults. For instance, the statement all `timer.stop` in the testcase stopped the active timers of the control part as well.

* It was impossible to specify value list type restrictions for TTCN–3 enumerated types because the compiler did not recognize the enumerated values within the subtype definition.

* The compiler accepted value range type restrictions for almost all built-in types although value ranges are allowed only for integer and float types.

* The predefined conversion functions str2int and str2float in the run-time environment accepted some invalid input strings. For instance if the numbers were followed by letters in the input string the numbers were converted and the remaining letters were silently ignored. Now these functions accept only valid inputs containing a valid integer or float value. An invalid input causes dynamic testcase error.

2127
* The compiler generated invalid (uncompilable) {cpp} code if the component reference in the `connect`, `disconnect`, `map` or `unmap` operation referred to an optional field of a record or set value because there was no conversion function to perform the implicit cast.
Elemer Lelik's avatar
Elemer Lelik committed
2128

2129
* The compiler aborted with a segmentation fault or similar error when trying to generate {cpp} code for the initial value of a component variable, which contained a `valueof` operation. Such constructs usually appear in the output of the TTCN–2 to TTCN–3 converter.
Elemer Lelik's avatar
Elemer Lelik committed
2130
2131
2132
2133
2134
2135
2136
2137
2138

* The utility `*ttcn3 logmerge*` reported memory leaks when the operating system’s limit for the maximum number of simultaneously open files was smaller than the number of input files. In this case the log merge utility has to create temporary files in order to perform the merge in several steps. When the temporary file was closed the internal memory structure associated to it was not deallocated. Apart from the warning this bug had no other side effects.

* The ASN.1 parser of the compiler did not recognize the EXPORTS ALL directive in the module and reported syntax error on it. This construct was introduced in the 2002 edition of the ASN.1 standard, its meaning is identical to the missing EXPORTS clause.

* The compiler rejected the expressions, in which a constant value was referenced with a non-constant index. The error message complained that an integer value was expected as index even if the referenced value was of type integer. Such constructs can be created, for instance, in the body of parameterized templates where the index value refers to a formal parameter of the template.

* The Main Controller entered an infinite loop and flooded the console with an endless sequence of error messages if the operating system’s limit of simultaneously open files was reached. This could happen when accepting the control TCP connections of newly created test components during load testing. The problem occurred on Solaris platform only. The reason was that the error codes of operating system calls were retrieved in an improper way and MC did not recognize the above situation.

2139
* If a literal value of TTCN–3 float type caused an overflow in the internal memory representationfootnote:[TTCN–3 float and ASN.1 REAL values are represented in the double type of the C/{cpp} language,which is mapped to 64-bit floating point numbers on most platforms.] the compiler stopped immediately with an internal fatal error during the parsing phase. Such situations are now handled properly and the compiler can continue its run after producing the appropriate error message.
Elemer Lelik's avatar
Elemer Lelik committed
2140
2141
2142
2143
2144

* The compiler aborted with an internal fatal error during code generation when it encountered a reference pointing to an element of a string value within template bodies or in the initial value of component variables. The code generator tried to follow the type of the embedded value and it handled the string element index in the same way as the indices of array and record of types.

* The run-time environment did not handle the variable assignments for record of and set of types properly. If the newly assigned value had fewer elements than the previous value of the variable the extra elements at the end were not erased from the variable. For example, if a variable contained three elements and the newly assigned value had only two, the new value of the variable had incorrectly three elements: the first two from the new value and the third one from the old value. This problem was present regardless whether the embedded type was a built-in or a user defined type or the extra values were bound or not. The effects of this bug were the most strange if a component variable of the MTC was initialized in the component type definition and several test cases were executed after each other.

2145
* The run-time environment caused dynamic test case error if an optional component of an ASN.1 `SEQUENCE` or `SET` type, the type of which was the ANY type, was assigned to an optional octetstring field of a TTCN–3 `record` or `set` type and the source field contained omit value. The appropriate {cpp} member function was missing and the {cpp} compiler performed an implicit conversion, which assumed that the value of the source field is present.
Elemer Lelik's avatar
Elemer Lelik committed
2146

2147
* In case of some valid, but sophisticated TTCN–3 or ASN.1 type recursion loops the compiler did not produce the equivalent {cpp} classes in the right bottom-up order. Thus the generated code was uncompilable because of forward referencing of incomplete types.
Elemer Lelik's avatar
Elemer Lelik committed
2148
2149
2150
2151
2152
2153
2154

* The Main Controller could report memory leaks if the configuration file passed to it contained syntax errors.

* The TTCN–3 parser of the compiler could not handle references pointing to an element of a multi-dimensional array in timer and port operations. It reported syntax error if the reference had more than one array indices, although the input was valid. The situation was the same if a component reference was embedded into a structured type and the `start`, `running` or `done` operation referred to a field of a variable.

* The compiler aborted with an internal fatal error during semantic analysis if the base template of a modified union template did not contain a specific value (e.g. it was a generic wildcard like "?").

2155
* The generated {cpp} code was uncompilable if an indexed element of a string value was assigned to a template. The {cpp} compiler complained about ambiguous function overloads in case of all string types (i.e. bitstring, hexstring, octetstring, charstring and universal charstring).
Elemer Lelik's avatar
Elemer Lelik committed
2156

2157
* The generated {cpp} code was uncompilable if an operand of a built-in TTCN–3 arithmetic, logical or string operation was a reference pointing to an optional field of a record or set value. The problem was present in case of all TTCN–3 operations that are mapped to infix {cpp} operators.
Elemer Lelik's avatar
Elemer Lelik committed
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175

* The HC logs contained incorrect information about the exit status of the test component if the corresponding UNIX process was terminated by a signal. In this case the log file showed a successful (zero) exit status although the process was aborted by a fatal error. Now the HC distinguishes between normal and abnormal process termination and reports the signal number instead of exit status in the latter case.

* Fixed segmentation fault in RAW encoder. The fault occurs if the length field is an union field and it stores the length of optional fields.

[[version-1-5-pl8]]
== Version 1.5.pl8

Released on November 5, 2004.

*New features*

* The `Makefile` generated by the compiler cuts the `.exe` suffix from the name of the executable on Windows platforms when running the command `make archive`.

* The compiler uses more efficient internal data structures, which reduces its memory usage by about 10%.

* The verification algorithm of `USER` limited licenses became more robust. Formerly only a reverse lookup was performed based on the numerical user ID (UID) of the process and the license was rejected if the UID was mapped to a login name different from that of the license file. Now, if this step fails a forward lookup is also performed on the login name of the license file. If the resulting UID matches the process UID the license is accepted. This makes the user name limited licensing working on UNIX systems where several login names are mapped to the same UID (e.g. portable Linux laptops with both local users and NIS membership). On such systems the reverse lookup returns one of the login names randomly.

2176
* The compiler generates the equivalent {cpp} code of TTCN–3 templates based on the output of semantic analysis. This means the following enhancements:
Elemer Lelik's avatar
Elemer Lelik committed
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197

* The compiler automatically re-arranges the initialization sequences for nonparameterized templates in case of forward referencing. It is not mandatory anymore to place such templates in bottom-up order in the module.

* If enum-hack is turned on the short form can be used for enumerated values within template bodies. The use of long form in functions, testcases and altsteps is still mandatory.

* The short-hand value list notation can be used in templates of record types.

* In-line compound expressions (including in-line modified templates) are supported as function or template actual parameters within template bodies.

* The run-time environment handles some test port errors in a more robust way. Formerly, if the `user map()` call failed (i.e. `TTCN error()` was called during its run) the test component registered the mapping before the error recovery. After the error recovery a regular unmap procedure was performed causing extra error messages.

* The run-time environment now supports the partial overwriting of generic wildcards ? and * in modified templates and template variables of structured TTCN–3 and ASN.1 types. When transforming a template from ? or * to a specific value the following rules are applied recursively:

* In case of record or set types all mandatory fields are set to ? and optional fields are set to *.

* In case of union types the selected field is set to ?.

* In case of record of or set of types all newly created elements up to and including the referred index are set to ?.

* The run-time environment executes the `EndTestCase` command, which is specified in section `[EXTERNAL COMMANDS]` of configuration file, after writing the verdict of test case into the log. Thus the external command can extract this verdict from the logand act accordingly.

2198
* The {cpp} mapping of TTCN–3 and ASN.1 import statements has been improved. These updates make the generated code compatible with the limitations of GCC 3.4 or above that are in place when precompiled header files are used. The following changes were implemented:
Elemer Lelik's avatar
Elemer Lelik committed
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209

* The #include directives are generated in the same order as the import statements are placed in the source module. This allows the explicit control which header file to be included first.

* Unnecessary #include directives are optimized out. For instance, if module C imports from both A and B and module B imports from A then `C.hh` will include only `B.hh` since `A.hh` is already included in `B.hh`.

* Base Library header files is not included directly if the module has imports.

* Circular import chains are handled in a special way.

* Logging of timers is now supported. That is, a reference to a timer can be an argument of a `TTCN–3 log()` statement. When executing the statement the attributes of the timer (state, default and actual duration, elapsed time) are printed into the log.

2210
* If the executable tests are built with GCC the {cpp} compiler will perform extra checks on the arguments of Base Library functions that have printf-like syntax. The variable arguments of `TTCN error()`, `TTCN warning()`, `TTCN Logger::log()`, `TTCN Logger::log event()`, etc. are verified against the format string. New warning messages may be displayed during the compilation of Test Ports and external functions if type mismatches are found.
Elemer Lelik's avatar
Elemer Lelik committed
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239

* Log Browser now is able to determine the component name from the log file name.

* Log Browser saves the configured view (columns shown) in the resource file.

* The Configuration Editor of the GUI has been rewritten. Now it also handles the comments in the configuration file. The comments should be above the assignments. See Part II of the link:https://github.com/eclipse/titan.core/tree/master/usrguide/userguide[TITAN TTCN–3 User Guide] for further details.

* The GUI does not open Process output tabs for the external text editor, Log browser and the font / look and feel configuration programs.

* The icon of the TTCN–3 and ASN.1 modules has changed to be brighter.

* The working directory defined in the GUI project now automatically belongs to the log file directories.

* The compiled executable’s path is now configurable for GUI projects.

* The Make archive item has been added to the GUI’s project menu.

* If running a command in a dialog window in the GUI (ie View execution statistics in on the Execution window) the dialog can be closed by clicking on the *Close* button in the lower-right corner.

* The %selectedfile names has been added to the GUI variables. This enables to call the text editor for the symlinks in the working directory, and not to open the file referenced by the symlink. Using this variable in the text editor command makes `ctags` program work as intended.

*Fixed bugs*

* The compiler issued misleading warning messages when it found circular imports between the TTCN–3 and ASN.1 modules. Irrelevant module names were listed and the closing module of the loop was missing.

* Several faults were corrected in the TTCN–3 and ASN.1 object identifier value checking algorithm of the compiler. Referenced values within `NameAndNumberForm` were not verified properly thus faulty input could result in unpredictable behavior during code generation. Referenced values containing module name and module objid caused memory leaks. If a TTCN–3 subtype constraint referred to an `objid` value having a faulty component the compiler stopped with an internal fatal error.

* If a TTCN–3 or ASN.1 integer constant was so large that it did not fit in the internal memory representation of the compiler (actually 64-bit signed integers are used) the compiler stopped immediately with an internal fatal error during parsing. Such overflow situations now produce regular error messages and the compiler can continue analyzing the input.

2240
* The compiler generated erroneous (uncompilable) {cpp} code for type alias definitions of port types and signatures.
Elemer Lelik's avatar
Elemer Lelik committed
2241
2242
2243
2244
2245

* The configuration file parser of the run-time environment accepted some invalid DNS names in section `[GROUPS]`. However, some valid names (e.g. names containing the dash character or having parts containing numbers only) were rejected.

* Circular recursions within parameterized template references could lead to infinite recursions in the compiler. A typical example for this situation: the body of a nonparameterized template refers to a parameterized template and one of the actual parameters is a reference to the non-parameterized template itself.

2246
* In some very rare cases the compiler generated invalid {cpp} code for message based port types. Data was read from an uninitialized memory location and in case of a specific bit pattern the compiler called both the message based and the procedure based code generator for the same port type.
Elemer Lelik's avatar
Elemer Lelik committed
2247

2248
* The compiler generated wrong (uncompilable) {cpp} code if a TTCN–3 charstring value contained non-printable characters. Such characters were created during constant folding (e.g. the output of function `int2char`, which was evaluated by the compiler).
Elemer Lelik's avatar
Elemer Lelik committed
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308

* Some compiler error messages reporting invalid RAW attributes printed memory garbage instead of TTCN–3 identifiers.

* The parser for the formal parameter lists of ASN.1 assignments was not implemented properly. It accepted all possible valid inputs, but some erroneous parameter lists as well.

* The compiler did not support the value list and value range subtype constraints for type universal charstring. Such constructs caused compilation errors.

* If a running operation was performed on an active, but already expired timer it disappeared from the list of active timers. After that the timer became invisible for operations `any timer.timeout` and all `timer.stop`.

* The RAW decoder did not handle the empty record of and set of values properly. If the octet stream contained no elements the corresponding value remained unbound after the decoding instead of containing an empty value (i.e. _{ }_).

* The GUI now shows a warning message if the symlink creation fails because a file named the same as the symlink exists in the working directory.

[[version-1-5-pl7]]
== Version 1.5.pl7

Released on September 20, 2004.

*New features*

* The logformat utility no longer wraps the quadruples of universal charstring values into several lines. In previous versions it inserted a newline character after the commas like in case of compound (e.g. record or set) values. Now the valid quadruples are recognized and kept in the same line as the other parts of the string.

* The semantic analysis was improved for procedure signatures. The error messages related to parameters became more intuitive.

* The semantic checking of modified templates has been improved. For instance, if the derivation path contained a circular recursion loop with 4 steps, the compiler printed the same error message 4 times after each other. The differences in the base and modified template’s formal parameters are reported now in a more intuitive way.

* The generated `Makefiles` distinguish between different Solaris versions to make it easier to create portable test ports. This is necessary because some socket handling function calls use different types of arguments on Solaris 2.6 and Solaris 8 systems. Now the `Makefile` generator of the compiler automatically recognizes the operating system version and sets the variable `PLATFORM` accordingly to `SOLARIS` on SunOS 5.6 (Solaris 2.6) and to `SOLARIS8` on `SunOS` 5.7 (Solaris 2.7) or above.

* The logging of procedure based port operations has been improved. For instance, in previous versions the name of the signature was logged twice when transmitting calls or replies. In case of exceptions only the signature name was logged, the type of the exception itself was missing.

* The snapshot manager of the run-time environment has been improved. It does not call the registered event handlers anymore when taking the first snapshot before evaluating an alternative. This results in higher execution speed and fair scheduling when running performance tests. In a typical case one call of the event handler can insert hundreds of messages into the port queue while an alt statement extracts only the first one. With the improved snapshot manager the event handlers are not called again while the port queue is not empty. The new algorithm has a drawback that it cannot cope with the `[else]` branches. Thus when the first `[else]` branch is executed the algorithm switches back to the original compatibility mode.

* Log browser tool has been added as stand-alone tool to browse log files, or can be used in the GUI.

* GUI Type browser tool has been added.

* User menus and editor for the User menus have been added to the GUI. The editor can be accessed on the Preferences *window/User* menus tab.

* Preferences window’s *General preferences* tab has been re-designed.

* New Help menu is added. It contains help index, contents, keyword search, license information and re-designed *About* dialog.

* The Process *output window* has been re-designed. Now it handles multiple running processes, each has its own output tab, and each can be stopped by the *Stop running* button.

* The Make, Clearcase and CVS menus have been rewritten for the GUI. Now they are configurable user menus.

* Test controls, test cases and test sets can be chosen and run by pressing the *Execute…* button in the Execution window.

* Statistics about the test execution can be viewed by using the View *execution statistics* toolbar button on the Execution window.

* The Execution window has been redesigned. Now it can be used both for single and parallel test execution. In parallel mode the default view now contains only the *Execute…* button. The detailed view can be switched on.

* Project properties window has been re-designed. General, log file, build and HC execution properties can be set on different tabs.

* The GUI supports starting multiple Host Controllers on different machines on the network.

*Fixed bugs*

* The compiler reported memory leak at termination if it encountered a `self.stop` or `mtc.stop` statement in its input module(s). A small memory block was not deallocated during the parsing of these constructs. This mistake had no other harmful side-effects.

2309
* The compiler generated invalid {cpp} code if a TTCN–3 `activate` operation was used as a function statement. This construct was introduced in the most recent BNF and the newly written code generator forgot to put a semi-colon at the end of the equivalent {cpp} statement.
Elemer Lelik's avatar
Elemer Lelik committed
2310

2311
* If a TTCN–3 or ASN.1 module contained an enumerated type and it was imported into another TTCN–3 module using the undocumented `"light" extension` attribute the {cpp} equivalent of the importing module was uncompilable. This option disables the processing of some sections of the imported {cpp} header file from the importing module by using the C preprocessor to reduce the compilation time for large projects. The masked section contains mainly the {cpp} equivalent classes of data types and in this case some in-line enumerated conversion functions in another (active) section referred to class members, which were invisible from the {cpp} translation unit of the importing module.
Elemer Lelik's avatar
Elemer Lelik committed
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330

* The compiler did not accept the hexadecimal string notation in ASN.1 modules for the values of the ANY type.

* The BER encoder did not detect if the octets of the value for an ASN.1 ANY type contained some extra bytes of garbage after a complete TLV. The accepted erroneous octet stream could cause failure during decoding.

* The behavior of the compiler was unpredictable when it processed asymmetric and non-internal procedure based port types. If the in and out lists contained different signatures the compiler usually crashed with a segmentation fault because the code generation routine tried to access the elements of the wrong list.

* In parallel mode the test components aborted with signal SIGPIPE (Broken pipe) if the `ConsoleMask` logging option was set to LOG ALL and the Main Controller has terminated unexpectedly (e.g. because Control-C was pressed on the command line). The components recognized the end of their control connection and therefore they tried to send a log message through the terminated TCP channel.

* The actual parameters of TTCN–3 entities were mapped to an improper data structure in the compiler’s abstract syntax tree. The corresponding BNF production is called `TemplateInstance`, which consists of an optional type, an optional derived reference and a mandatory template body. For instance, in the former implementation the type part (if it was present) was excluded from the semantic analysis. At the same time the error messages that are used to report incorrect actual parameters were also improved.

* If the compiled Executable Test Suite was started with the command line switch `-l` (in order to obtain the list of test cases and control parts) and any internal error occurred during the initialization of the run-time environment, the ETS did not print anything and returned a successful (zero) exit status. Seeing this behavior it can be assumed that the modules contain no executable test cases or control parts. Now the ETS prints the error message to its `stderr` and returns a non-zero exit status.

* The handling of the list of active event handlers was implemented incorrectly in the snapshot manager of the test components, which is a part of the Base Library. This could result in the unpredictable behavior of the test component in some race conditions. For example, if the termination of a port mapping was requested from a remote test component (by using an `unmap` operation) and at the same time data has arrived on the registered file descriptor of the corresponding Test Port, it could happen that the snapshot manager called the `Event Handler()` function of the Test Port after completing the `unmap` operation (i.e. calling user `unmap()`), which already performed the deactivation of the event handler.

* The compiler did not accept the valid null value as initial value for component variables with type default or a component type. It reported semantic errors for those definitions.

* The compiler aborted with an internal fatal error during error recovery (i.e. after reporting the error) if an invalid `SEQUENCE` notation was used for an ASN.1 REAL value.

2331
* The generated {cpp} code could be uncompilable due to ambiguous function overloads in the class that implements TTCN–3 port types if the support of address type was turned on (i.e. the extension attribute `address` was used in the port type). The problem appeared only if the port type had outgoing messages or signatures and the address type was aliased to a built-in type the {cpp} equivalent class of which had a constructor with `int` parameter (e.g.` integer`, objid and all string types). The reason was a missing explicit cast in a generated function and the {cpp} compiler could not distinguish between component references and address values.
Elemer Lelik's avatar
Elemer Lelik committed
2332

2333
* The compiler produced invalid {cpp} code if the to clause was present in a TTCN–3 `raise` port operation. The generated code contained an unnecessary extra closing parenthesis.
Elemer Lelik's avatar
Elemer Lelik committed
2334

2335
* The semantic analyzer of the compiler did not report error if it encountered a length restriction or `ifpresent` matching mechanism in an actual value parameter of a template or function. It simply ignored the extra matching attributes and analyzed the specific value only. The generated {cpp} code was uncompilable in these cases.
Elemer Lelik's avatar
Elemer Lelik committed
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369

* The special component references such as `null`, `mtc`, `system` and `self` were not handled in component `start` operations. Thus the run-time error messages were cryptic when the argument of start was one of the above.

* The entries of the alphabetical index in this document contained wrong page numbers. This was because the index was built before the table of contents and the pages occupied by the latter were neglected.

* The RAW type descriptor of charstring type was missing causing segmentation fault during RAW encoding/decoding.

* Utility `*ttcn3 logmerge*` printed garbage characters to the output if the component identifier part of input file name was longer than 30 characters. By default the component identifier is the numeric component reference, which cannot be so long, but in case of custom filename skeletons that part can contain any string.

* The semantic analyzer of the compiler could reject some valid TTCN–3 constant definitions by printing mysterious error messages. The problem occurred if a referenced value with field or array sub-references pointed to a sub-field of another referenced compound value.

* There were some minor mistakes in the semantic checking algorithms of value ranges within template bodies: The compiler did not check the upper bound if the lower bound was set to minus infinity. The `ifpresent` matching attribute of value ranges was reported twice if it was inappropriate.

* The ASN.1 parser of the compiler did not accept the construct `ObjectClassFieldType` in `FixedTypeValueFieldSpec`.

* The semantic analyzer of the compiler was unable to detect circular recursion loops in template references.

* Infinite type recursions (e.g. when a TTCN–3 record type contains itself as a mandatory field) caused stack overflow and segmentation fault in the compiler. Moreover, the compiler was unable to detect the similar embedded recursions within constants and templates of valid recursive types (e.g. when a field of a structured value refers back to the whole value).

[[version-1-5-pl6]]
== Version 1.5.pl6

*Released on June 11, 2004.*

*New features*

* The compiler and the run-time environment supports the following non-standard TTCN–3 language extensions, which allow the dynamic creation of templates during test execution. In the future these constructs will be added to the TTCN–3 standard in the same or very similar form.

* Functions and external functions may return templates (i.e. all permitted matching mechanisms in addition to specific values) if the return type is defined as template.

* It is allowed to define template variables at any place where the definition of regular (value) variables is permitted. The value of such variables may be dynamically assigned and they can carry any permitted matching mechanism.

* It is allowed to pass template parameters to functions, `altsteps` and `testcases` by reference. Those parameters are denoted by the keywords `out` or `inout` similarly to value parameters. The actual parameters shall be template variables.

2370
* The conversion functions related to enumerated types are no longer global C functions. They were moved to static members of the value class. This makes easier to write generic {cpp} template functions in Test Ports that can handle any enumerated type.
Elemer Lelik's avatar
Elemer Lelik committed
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385

* The script `*ttcn3 start*` handles the configuration files automatically. If it finds a file named `<ETS name>.cfg` in its current working directory it passes the file to MC as a command line argument.

* New compiler flag `-B` added to generate browserdata.dat needed by the visual type browser (part of GUI).

* The RAW attribute `HEXORDER` is now applicable to the octetstring type besides hexstring type. The `HEXORDER(high)` settings will twist the nibbles within an octet during encoding and decoding.

* The new command `make check` was introduced in the `Makefile` generated by the compiler, which performs syntax and semantic checks on the TTCN–3 and ASN.1 modules.

*Fixed bugs*

* The Main Controller behaved incorrectly during the shutdown procedure after the `exit` command. There was an unhandled race condition between the internal threads, which had noticeable effects only on Linux. The MC sometimes reported memory leaks or segmentation fault occurred or the final _Shutdown complete._ message was missing. On other platforms the problem remained hidden due to the different thread scheduling algorithms of the operating systems.

* The type descriptor needed for the RAW encoding of the boolean type was missing from the run-time environment. This resulted in segmentation fault if a message containing a boolean field was encoded or decoded.

2386
* The compiler accepted an invalid syntax for catching timeout on procedure based ports. The string `catch timeout` was interpreted as a `catch` operation in addition to the standard `PortReference.catch(timeout)` notation. Moreover, the standard syntax produced invalid {cpp} output, only the irregular variant resulted in working code. Only the standard syntax is accepted from now, and it is translated to a valid {cpp} code.
Elemer Lelik's avatar
Elemer Lelik committed
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400

* The compiler returned a misleading successful (zero) exit status if it encountered a general problem with an input file (e.g. the file could not be opened or classified as a TTCN–3 or ASN.1 module).

* The Main Controller did not set the close-on-exec flag on its socket file descriptors that were used for communication with the other processes of the test system (HCs and test components). As a result of this all commands launched from the user interface (e.g. the text editor started from the GUI) inherited the open files. If the process did not finish before the end of the test session the MC could not close the TCP connections properly.

[[version-1-5-pl5]]
== Version 1.5.pl5

Released on April 30, 2004.

*New features*

* The compiler is able to generate `Makefiles` to be used in single mode with the newly introduced command line switch `-s`.

2401
* The `Makefile` generator of the compiler recognizes if a given {cpp} source file is generated from one of the TTCN–3 or ASN.1 modules. In this case a warning is issued and the given file is not added to the list of USER SOURCES.
Elemer Lelik's avatar
Elemer Lelik committed
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420

* The compiler became less strict regarding the usage of semi-colons within `TTCN–3modulepar` blocks. The compiler treats the semi-colons optional, but it issues a warning if the input does not conform to the standard TTCN–3 BNF.

* If the Test Port writer tries to register the event handler on a bad (e.g. nonexistent) file descriptor, the run-time environment reports this error immediately when Install Handler member function is called. In earlier versions the error was detected later by the select system call when taking a new snapshot. It was more difficult to determine the origin of the error if more than one Test Ports were used in the same test component.

* The logging of location information has been improved. The line numbers are more accurate (e.g. when a TTCN–3 function is called from a send or receive template). It is possible to log the entire call stack and the name of the current TTCN–3 function, testcase or altstep.

* The compiler prints correct location information for errors and warnings found in ASN.1 `OBJECT IDENTIFIER`, Relative-OID and TTCN–3 `objid` values. The error recovery is also supported in these values. In earlier versions the compiler stopped after finding the first error in these values.

*Fixed bugs*

* The compiler terminated with a segmentation fault during error recovery if it encountered more than one opening brackets (_{_) without closing pairs in ASN.1 modules.

* The compiler aborted with an internal fatal error if a referenced value or template of wrong type was used as a template for an enumerated type. The error occurred when the compiler tried to print the ’type mismatch’ error message.

* The compiler aborted with an internal fatal error instead of printing the appropriate error message if the empty record/set value (i.e. _{ }_) was given as a TTCN–3 template for a union type. If the union template contains (incorrectly) more than one selected fields, the compiler checks now every field template against the corresponding field type after printing the error message.

* If the compiler generated a `Makefile` to be used with GNU make and all user source files had the `.cc` suffix, but one or more of them did not have its own header file, the suffix substitution rule was not used to obtain the list of object files. In this case only the user header files have to be explicitly enumerated, the names of object files do not need to be enumerated.

2421
* The `sizeof` built-in function could not be used on optional record or set fields (or their ASN.1 equivalents) if the type of the field was a `record of` or `set of` type. The generated {cpp} code did not compile in these cases, the compiler complained about no matching function.
Elemer Lelik's avatar
Elemer Lelik committed
2422
2423
2424
2425
2426
2427
2428

* If the body of a parameterized template used a formal parameter with field or array sub-references, the compiler evaluated the type of the reference expression incorrectly and thus reported type mismatches on valid templates. For instance, if the type of a formal parameter was a record with an integer field then the compiler assumed that the type of the formal parameter reference with the field sub-reference is the record type and not integer.

* The compiler reported fake circular value recursion if an expression within an array index contained a nested array reference. The reason was that the names of some nodes in the compiler’s internal syntax tree were not set and the recursion detection algorithm saw empty strings instead of the real names.

* The ASN.1 parser of the compiler did not consider the default tagging method correctly. If an embedded block (e.g. a `CHOICE` type) contained tagged types, the compiler decided whether to use implicit or explicit tags based on the default tagging method of the lastly parsed ASN.1 module instead of the current module. The problem was visible only if the input ASN.1 modules did not use the same default tagging method, which happens rarely.

2429
2430
* The type descriptor structures in the Base Library were not declared for TTCN–3 type universal charstring. This caused compilation errors in the generated {cpp} code if the universal charstring type was embedded into a record, set or union type. The problem did not affect the ASN.1 character string types.
* The precedence requirements for RAW attributes `PRESENCE` and `CROSSTAG` were not checked at compilation. Such kinds of errors caused dynamic test case errors (i.e. when the field that determines the presence or selection of another field is encoded at a later position in the message than the field it points to). These problems are now detected by the compiler and no {cpp} code is generated for faulty types.
Elemer Lelik's avatar
Elemer Lelik committed
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506