Sync with 5.4.0

[deliverable/titan.core.git] / regression_test / compileonly / dynamicTemplate / DynamicTemplate.ttcn

/******************************************************************************
 * Copyright (c) 2000-2015 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 ******************************************************************************/
module DynamicTemplate {

// Prerequisites

type integer T1;

type record T2 {
    bitstring f1 optional,
    objid f2,
    T1 f3
}

type set T3 {
    octetstring f1,
    T2 f2 optional,
    verdicttype f3
}

type union T4 {
    boolean f1,
    T2 f2,
    T3 f3,
    T5 f5
}

type record of hexstring T5;

type set of T4 T6;

type port PT message {
    inout bitstring, T6;
} with { extension "internal" }

template bitstring t1 := '10?01*1'B;

// Test Cases

// DynamicTemplate-001
function f1(boolean flag) return template bitstring
{
    var boolean flag2 := true;
    if (flag) {
	// DynamicTemplate-006
        return not4b ('1001'B & '0110'B);
    } else if (flag2) {
	// DynamicTemplate-007
	return t1;
    } else {
	// DynamicTemplate-008
	return ?;
    }
}

// DynamicTemplate-002
external function ef1() return template float;

// DynamicTemplate-003
function f2(template T6 par_t6) runs on C return template T6
{
    if (flag) {
	// DynamicTemplate-009
	return {
	    vt4,
	    *,
	    { f5 := { 'AB?C'H, '*F'H, ''H } },
	    { f2 := { f1 := *, f2 := objid { 1 2 3 4 }, f3 := (1..10) } },
	    { f3 := { f1 := '12*AB'O,
	        f2 := { f1 := omit, f2 := ?, f3 := complement(5, 10, 13) } ifpresent,
		f3 := (pass, fail) }
	    }
	} length(7..9);
    } else {
        var boolean flag2 := true;
	if (flag2) {
	    // DynamicTemplate-010
	    return par_t6;
	} else {
	    // DynamicTemplate-011
	    // DynamicTemplate-025
	    return vt6;
	}
    }
}

// DynamicTemplate-004
external function ef2() return template T3;

// DynamicTemplate-012
template bitstring t2(boolean flag) := f1(flag);

// DynamicTemplate-013
function f2b() runs on C
{
    var template T6 tmp := f2(f2(f2(?)));
}

// DynamicTemplate-014
function f2c() runs on C
{
    P.send(f1(true));
    P.send(bitstring:f1(true));
    P.receive(f2(?));
    P.receive(T6:f2(?));
}

// DynamicTemplate-015
function f2d()
{
    var T6 v1 := valueof(f2({}));
    if (match(v1, f2(?))) { }
}

type component C {
    port PT P;
    var boolean flag;
    // DynamicTemplate-016
    var template octetstring vt1;

    // DynamicTemplate-017
    var template integer vt2 := 5;

    // DynamicTemplate-018
    var template bitstring vt3:= complement('1*1'B, '01?0'B, '1'B) ifpresent;

    // DynamicTemplate-019
    var template T4 vt4;

    // DynamicTemplate-020
    var template T3 vt5 := { f1 := ?, f3 := error };

    // DynamicTemplate-021
    // DynamicTemplate-025
    var template T6 vt6 := { { f1 := false }, { f2 := ? },
       { f3 := { f1 := ?, f2 := *, f3 := ? } } };


    // DynamicTemplate-022
    var template integer vt7[100];
    var template float vt8[3] := { (0.0 .. 0.5), (1.0 .. 1.5), (2.0 .. 2.5) };

    // DynamicTemplate-023
    var template T5 vt9[3][5];
    var template octetstring vt10[3][2][2] :=
        { { { ''O, ''O }, { ?, * } }, -, { { '00'O, 'FF'O }, { '?'O, '*'O } } };

    // DynamicTemplate-024
    var template T2 vt10a, vt10b[2] /*, vt10c[1][1]*/;
    var template integer vt11a := 1, vt11b := ?, vt11c[2] := { complement(1), 2 };
}

// DynamicTemplate-026
function f3()
{
    // DynamicTemplate-026
    var template charstring vt1 := pattern "AB?C*";
    var template T6 vt2[1], vt3 := *;
    // DynamicTemplate-027
    do {
	var template T5 vt4 := ({ }, { (''H, '?'H) }, { '1?'H, '2*'H });
    } while (false);
    // DynamicTemplate-028
    for (var template integer i := 0; valueof(i) < 10; i := valueof(i) + 1) {
    }
}

// DynamicTemplate-029
testcase tc1() runs on C
{
    var template T2 vt12 := { f1 := omit };
}

// DynamicTemplate-030
altstep as1()
{
    var template integer vti := 1;
    var template T6 vt6 := ?;
    [] any timer.timeout {
	// DynamicTemplate-032
	var template bitstring vbs[10], vbs2 := '10??10*1?0'B;
    }
    [] any component.done {
	// DynamicTemplate-033
	var template octetstring vbs2, vbs;
    }
}

function f4() {
    var bitstring v1 := '1001'B;
    var template bitstring vt1;
    var template T6 vt2;
    // DynamicTemplate-034
    vt1 := '0110'B;
    vt1 := not4b (v1 & v1);
    // DynamicTemplate-035
    vt1 := t1;
    // DynamicTemplate-036
    vt1 := ?;
    // DynamicTemplate-037
    vt1 := f1(false);
    // DynamicTemplate-038
    vt2[0].f1 := ?;
}

function f5() runs on C return template T6 {
    var template T6 vt12 := {}, vt13;
    var T6 v1;
    // DynamicTemplate-039
    vt13 := f2(vt12);
    // DynamicTemplate-040
    P.send(vt12);
    P.send(T6:vt12);
    P.receive(vt13);
    P.receive(T6:vt13) -> value v1;
    // DynamicTemplate-041
    v1 := valueof(vt12);
    // DynamicTemplate-042
    if (match(v1, vt13)) { }
    // DynamicTemplate-011
    return vt13;
}

// DynamicTemplate-043
// DynamicTemplate-045
function f6(in template integer par1, inout template bitstring par2,
    out template objid par3) {
}

// DynamicTemplate-044
function f7(inout template T3 par1, out template T5 par2,
    in template T6 par3) runs on C {
}

// DynamicTemplate-046
external function ef3(in template T1 par1, inout template T2 par2,
    out template T3 par3);

// DynamicTemplate-047
testcase tc2(in template T4 par1, inout template T5 par2,
    out template T6 par3) runs on C {
}

// DynamicTemplate-048
altstep as2(in template float par1, out template octetstring par2,
    inout template universal charstring par3) {
    [] any timer.timeout { }
}

function f8(out template T6 par1, inout template bitstring par2) runs on C {
    var bitstring vbs;
    var template bitstring vtbs;
    // DynamicTemplate-049
    par1 := { ?, ? };
    par1[0] := { f1 := ? };
    // DynamicTemplate-050
    vtbs := par2;
    // DynamicTemplate-051
    f6(1, par2, par1[1].f2.f2);
    // DynamicTemplate-052
    P.send(par2);
    P.receive(par2);
    // DynamicTemplate-053
    vbs := valueof(par2);
    if (match(vbs, par2)) { }
}


// DynamicTemplate-030
control {
    var template verdicttype vt := complement(fail);
}

}