Last sync 2016.04.01

[deliverable/titan.core.git] / regression_test / modifiedTemplate / TmodifiedTemplate.ttcn

/******************************************************************************
 * Copyright (c) 2000-2016 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
 *
 * Contributors:
 *   Balasko, Jeno
 *   Kovacs, Ferenc
 *   Raduly, Csaba
 *   Szabados, Kristof
 *   Szabo, Janos Zoltan – initial implementation
 *
 ******************************************************************************/
module TmodifiedTemplate {

type record SIGNAL1
{
  REC1 rec1
}

type record REC1
{
  integer a,
  integer b
}

template SIGNAL1 templateB :=
{
  rec1:= ?
}

template SIGNAL1 templateC modifies templateB :=
{
  rec1 :=
  {
    a := 3
  }
}

template SIGNAL1 templateD modifies templateB :=
{
  rec1 :=
  {
    a := 3,
    b := 4
  }
}


type port TP message {
  inout SIGNAL1;
} with { extension "internal" }

type component main {
  port TP tp;
  port TP tp2;
}

testcase tc1() runs on main {
  connect(mtc:tp, mtc:tp2);
  tp.send(templateD);
  log(templateC);
  tp2.receive(templateC);
  setverdict(pass);
}

type record R {
  integer f1,
  integer f2 optional
}

type record RR { // exactly the same
  integer f1,
  integer f2 optional
}

template R tbase := ?;
template R t1 modifies tbase := { f1 := 1 }; // 1, *
template R t2 modifies tbase := { f2 := 2 }; // ?, 2

const R c1 := { 1, 2 }; // matches t1, t2
const R c2 := { 1, omit }; // matches t1
const R c3 := { 2, 2 }; // matches t2
const R c4 := { 3, 4 }; // matches none

type component CT { };

testcase tc2() runs on CT
{
  var template R vtbase := tbase;

  log(t1);
  log(t2);

  if (match(c1, t1)) { setverdict(pass); }
  else { setverdict(fail); }
  if (match(c1, /* R : */ modifies vtbase := { f1 := 1 })) { setverdict(pass); }
  else { setverdict(fail); }
  if (match(c1, t2)) { setverdict(pass); }
  else { setverdict(fail); }
  if (match(c1, R : modifies vtbase := { f2 := 2 })) { setverdict(pass); }
  else { setverdict(fail); }

  if (match(c2, t1)) { setverdict(pass); }
  else { setverdict(fail); }
  if (match(c2, R : modifies vtbase := { f1 := 1 })) { setverdict(pass); }
  else { setverdict(fail); }
  if (match(c2, t2)) { setverdict(fail); }
  else { setverdict(pass); }
  if (match(c2, /* R : */ modifies vtbase := { f2 := 2 })) { setverdict(fail); }
  else { setverdict(pass); }

  if (match(c3, t1)) { setverdict(fail); }
  else { setverdict(pass); }
  if (match(c3, R : modifies vtbase := { f1 := 1 })) { setverdict(fail); }
  else { setverdict(pass); }
  if (match(c3, t2)) { setverdict(pass); }
  else { setverdict(fail); }
  if (match(c3, R : modifies vtbase := { f2 := 2 })) { setverdict(pass); }
  else { setverdict(fail); }

  if (match(c4, t1)) { setverdict(fail); }
  else { setverdict(pass); }
  if (match(c4, R : modifies vtbase := { f1 := 1 })) { setverdict(fail); }
  else { setverdict(pass); }
  if (match(c4, t2)) { setverdict(fail); }
  else { setverdict(pass); }
  if (match(c4, R : modifies vtbase := { f2 := 2 })) { setverdict(fail); }
  else { setverdict(pass); }
}

type union U {
  R altr
}

type record of R RofR;

testcase tc3() runs on CT
{
  var template U tu := ?;
  tu.altr.f1 := 1;
  log(tu);
  var template RofR vt := *;
  vt[5].f2 := 5;
  log(vt);
  // todo: add more specific tests
  setverdict(pass);
}

type record MyRecordType {
  integer field1 optional,
  charstring field2,
  boolean field3
}

// With value parameters.

template MyRecordType MyTemplate11(integer p_int := 5) := {
  field1 := p_int,
  field2 := "A string",
  field3 := true
}

template MyRecordType MyTemplate12(integer p_int) modifies MyTemplate11 := {
  // p_int had a default value in MyTemplate11 but has none in this template
  field2 := "B string"
}

template MyRecordType MyTemplate13(integer p_int := 0) modifies MyTemplate12 := {
  // p_int has the default value 0
  // no change is made to the template's content, but only to the default value of p_int
  field2 := "C string"
}

template MyRecordType MyTemplate14(integer p_int := -) modifies MyTemplate13 := {
  // p_int inherits the default value 0 from its parent MyTemplate13
  field2 := "D string"
}

template MyRecordType MyTemplate15(integer p_int := -) modifies MyTemplate14 := {
  // p_int inherits the default value 0 from MyTemplate13 via MyTemplate14
  field2 := "E string"
}

// With template parameters.

template MyRecordType TMyTemplate11(template integer p_int := 5) := {
  field1 := p_int,
  field2 := "A string",
  field3 := true
}

template MyRecordType TMyTemplate12(template integer p_int) modifies TMyTemplate11 := {
  // p_int had a default value in MyTemplate11 but has none in this template
  field2 := "B string"
}

template MyRecordType TMyTemplate13(template integer p_int := 0) modifies TMyTemplate12 := {
  // p_int has the default value 0
  // no change is made to the template's content, but only to the default value of p_int
  field2 := "C string"
}

template MyRecordType TMyTemplate14(template integer p_int := -) modifies TMyTemplate13 := {
  // p_int inherits the default value 0 from its parent MyTemplate13
  field2 := "D string"
}

template MyRecordType TMyTemplate15(template integer p_int := -) modifies TMyTemplate14 := {
  // p_int inherits the default value 0 from MyTemplate13 via MyTemplate14
  field2 := "E string"
}

testcase ETSI_CR5091() runs on CT
{
  template MyRecordType LMyTemplate11 := MyTemplate11()
  template MyRecordType LMyTemplate12 := MyTemplate12(1)
  template MyRecordType LMyTemplate13 := MyTemplate13()
  template MyRecordType LMyTemplate14 := MyTemplate14()
  template MyRecordType LMyTemplate15 := MyTemplate15()
  template MyRecordType LTMyTemplate11 := TMyTemplate11()
  template MyRecordType LTMyTemplate12 := TMyTemplate12(1)
  template MyRecordType LTMyTemplate13 := TMyTemplate13()
  template MyRecordType LTMyTemplate14 := TMyTemplate14()
  template MyRecordType LTMyTemplate15 := TMyTemplate15()
  if (valueof(LMyTemplate11.field1) == 5) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LMyTemplate12.field1) == 1) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LMyTemplate13.field1) == 0) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LMyTemplate14.field1) == 0) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LMyTemplate15.field1) == 0) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LTMyTemplate11.field1) == 5) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LTMyTemplate12.field1) == 1) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LTMyTemplate13.field1) == 0) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LTMyTemplate14.field1) == 0) { setverdict(pass) } else { setverdict(fail) }
  if (valueof(LTMyTemplate15.field1) == 0) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 5, "A string", true }, MyTemplate11())) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 1, "B string", true }, MyTemplate12(1))) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 0, "C string", true }, MyTemplate13())) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 0, "D string", true }, MyTemplate14())) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 0, "E string", true }, MyTemplate15())) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 5, "A string", true }, TMyTemplate11())) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 1, "B string", true }, TMyTemplate12(1))) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 0, "C string", true }, TMyTemplate13())) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 0, "D string", true }, TMyTemplate14())) { setverdict(pass) } else { setverdict(fail) }
  if (match({ 0, "E string", true }, TMyTemplate15())) { setverdict(pass) } else { setverdict(fail) }
}

testcase HO10136_sideeffect() runs on CT
// A side-effect of the first attempt to fix HO10136 caused the compiler
// to generate C++ code that could not be compiled.
{
  template integer v_timeUnit := 60;
  
  template R v_r modifies tbase := {
    f1 := v_timeUnit // this line was miscompiled
  }
  
  if (valueof(v_r.f1) == 60) { setverdict(pass) } else { setverdict(pass) }
}

control {
  execute( tc1() );
  execute( tc2() );
  execute( tc3() );
  execute( ETSI_CR5091() );
  execute( HO10136_sideeffect() );
}

}