/******************************************************************************
 * 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
 *   Raduly, Csaba
 *
 ******************************************************************************/
module all_from_complement { // ETSI CR 6088
import from types all;
import from functions all;
import from imported_templates all;

// B 1.2.1 Template List
// "It can be used on values of all types"

//just to test these types as well:
modulepar RoI tsp_RoI3 := {20,21,22};
modulepar RoI tsp_SoI3 := {20,21,22};

const RoI c_RoI3 := {20,21,22};
const SoI c_SoI3 := {20,21,22};

//============Record of Integer============================
template RoI t_RoI1 := {1, 2, (6..9)};
template RoI t_RoI2 := {1, *, 3};
template RoI t_RoI3 := {20,21,22};
template RoI t_RoI4 := {1, ?, 3};

//template RoI t_RoI1c :=  {complement (1),complement (2), complement(6)};
 
template integer t_i0 := complement(all from t_RoI1);
template integer t_i0_eq := complement (1, 2, (6..9));

template integer t_i1 := complement(all from t_RoI1, 100);        
template integer t_i1_eq :=complement(1, 2, (6..9), 100);

template integer t_i2 := complement (-1,0,all from t_RoI1, 100);
template integer t_i2_eq := complement (-1,0,1, 2, (6..9), 100);

template integer t_i3 := complement (-1,0,all from t_RoI1, all from t_RoI3, 100);
template integer t_i3_eq := complement (-1,0,1, 2, (6..9),20,21,22, 100);

template integer t_i4 := complement (-1,0,all from t_RoI1, 100, all from t_RoI3);
template integer t_i4_eq := complement (-1,0,1, 2, (6..9),100,20,21,22 );

template integer t_i5 := complement (-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3 ); //repetition
template integer t_i5_eq := complement (-1,0,1, 2, (6..9),100,20,21,22,20,21,22);

template integer t_i6 := complement (-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3,all from t_RoI3); //repetition
template integer t_i6_eq := complement (-1,0, 1, 2, (6..9),100,20,21,22,20,21,22,20,21,22);
//from modulepar:
template integer t_i13roi := complement(all from tsp_RoI3);
template integer t_i13_eq := complement(20,21,22);
template integer t_i13soi := complement(all from tsp_SoI3);

//from const:
template integer t_i13roi_c := complement(all from c_RoI3);
template integer t_i13soi_c := complement(all from c_SoI3);
//=== All from referring remote templates (imported templates)
template integer t_importing_i0 := complement(all from t_imported_RoI1);
template integer t_importing_i1 := complement(all from t_imported_RoI1, 100);
template integer t_importing_i2 := complement(-1,0,all from t_imported_RoI1, 100);
template integer t_importing_i3 := complement(-1,0,all from t_imported_RoI1, all from t_imported_RoI3, 100);
template integer t_importing_i4 := complement(-1,0,all from t_imported_RoI1, 100, all from t_imported_RoI3);
template integer t_importing_i5 := complement(-1,0,all from t_imported_RoI1, 100,all from t_imported_RoI3,all from t_imported_RoI3 ); //repetition
template integer t_importing_i6 := complement(-1,0,all from t_imported_RoI1, 100, all from t_imported_RoI3,all from t_imported_RoI3,all from t_imported_RoI3); //repetition
template integer t_importing_i7 := complement(all from t_imported_RoI4,100);
template integer t_importing_i8 := complement(100,all from t_imported_RoI4);
template integer t_importing_i9 := complement(100,all from t_imported_RoI4,-1);
//===========Set of Integer================================
template SoI t_SoI1 :=  {1, 2, (6..9)};
template SoI t_SoI2 :=  {1, *, 3};
template SoI t_SoI3 :=  {20,21,22};

template integer t_i0s    := complement(all from t_SoI1);
template integer t_i0s_eq := complement( 1,2,(6..9));

template integer t_i1s := complement(all from t_SoI1, 100);
template integer t_i1s_eq := complement( 1,2,(6..9),100);
// equivalent to         (1, 2, (6..9)   , 100);

template integer t_i2s := complement(-1,0,all from t_SoI1, 100);
template integer t_i2s_eq := complement( -1,0,1,2,(6..9),100);

template integer t_i3s := complement(-1,0,all from t_SoI1, all from t_SoI3, 100);
template integer t_i3s_eq := complement( -1,0,1,2,(6..9),20,21,22,100);

template integer t_i4s := complement(-1,0,all from t_SoI1, 100, all from t_SoI3);
template integer t_i5s := complement(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
template integer t_i6s := complement(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3,all from t_SoI3); //repetition

//===========Record of of charstring================================
template RoCS t_RoCS1 := { "apple","banana","","pear"};
template RoCS t_RoCS2 := { "apples","bananas","","pears"};
template charstring t_cs1 := complement ( all from t_RoCS1, "dog" );
template charstring t_cs2 := complement ( "treeeeeeeeeeeeee",all from t_RoCS1, "dog", all from t_RoCS2);
//==== function reference =====
template RoF_int2int t_rofref_int2int := { refers(f_int2int_1),refers(f_int2int_2) }
template F_int2int t_fref_int2int_c := complement( all from t_rofref_int2int );
template F_int2int t_fref_int2int_c_eq := complement( refers(f_int2int_1),refers(f_int2int_2)  );
//============== Test for Integer List ================================
 
//----- Tests for static templates ------

//real static template, without any manipulation
testcase tc_complementInt() runs on A
{
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
  action("t_i1=", t_i1, " will be checked against ",vl_goodValues);
  var integer N:=sizeof(vl_goodValues);
  for(var integer i:=0;i<N;i:=i+1) {
    if (match(vl_goodValues[i], t_i1)) { setverdict(pass); }
    else { setverdict(fail,vl_goodValues[i], " should match ", t_i1); }
  }

  var RoI vl_badValues := { 1,2,6,7,8,9,100};  
  action("t_i1=", t_i1, " will be checked against ",vl_badValues);
  N:=sizeof(vl_badValues);
  for(var integer i:=0;i<N;i:=i+1) {
    if (not match(vl_badValues[i], t_i1)) { setverdict(pass); }
    else { setverdict(fail,vl_badValues[i], " should match ", t_i1); }
  }

}
//=== i0 ===
//complement(1, 2, (6..9));
testcase tc_complementInt0_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i0,t_i0_eq);
}

testcase tc_complementImportingInt0_eq() runs on A{
  f_checkIntTemplateEquivalence(t_importing_i0,t_i0_eq);
}

testcase tc_complementInt0() runs on A
{
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := {1,2,6,7,8,9};
  f_checkIntegerTemplate(t_i0,vl_goodValues,vl_badValues);
}
testcase tc_complementImportingInt0() runs on A
{
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := {1,2,6,7,8,9};
  f_checkIntegerTemplate(t_importing_i0,vl_goodValues,vl_badValues);
}
//=== i1 ===
//complement(1, 2, (6..9), 100);
testcase tc_complementInt1_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i1,t_i1_eq);
}
testcase tc_complementInt1() runs on A
{
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := { 1,2,6,7,8,9,100};
  f_checkIntegerTemplate(t_i1,vl_goodValues,vl_badValues);
}

//complement (-1,0,1, 2, (6..9), 100);
testcase tc_complementInt2_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i2,t_i2_eq);
}
testcase tc_complementInt2() runs on A
{
  var RoI vl_goodValues :={ -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues :=  { -1,0,1,2,6,7,8,9,100};
  f_checkIntegerTemplate(t_i2,vl_goodValues,vl_badValues);
}

//complement (-1,0,1, 2, (6..9),20,21,22, 100);
testcase tc_complementInt3_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i3,t_i3_eq);
}
testcase tc_complementInt3() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
  f_checkIntegerTemplate(t_i3,vl_goodValues,vl_badValues);
}

//order
testcase tc_complementInt4_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i4,t_i4_eq);
}
testcase tc_complementInt4() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000}; 
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22}; 
  f_checkIntegerTemplate(t_i4,vl_goodValues,vl_badValues);
}
//repetition

testcase tc_complementInt5_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i5,t_i5_eq);
}
testcase tc_complementInt5() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
  f_checkIntegerTemplate(t_i5,vl_goodValues,vl_badValues);
}
//=== i6 ===
testcase tc_complementInt6_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i6,t_i6_eq);
}
testcase tc_complementInt6() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
  f_checkIntegerTemplate(t_i6,vl_goodValues,vl_badValues);
}
//=== i13 ===
//modulepar test

testcase tc_complementInt13roi_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i13roi,t_i13_eq);
}
testcase tc_complementInt13roi() runs on A
{
  var RoI vl_goodValues := {-1,19,23,24,100};  
  var RoI vl_badValues := { 20,21,22};
  f_checkIntegerTemplate(t_i13roi,vl_goodValues,vl_badValues);
}
testcase tc_complementInt13soi_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i13soi,t_i13_eq);
}
testcase tc_complementInt13soi() runs on A
{
  var RoI vl_goodValues := {-1,19,23,24,100};  
  var RoI vl_badValues := { 20,21,22};
  f_checkIntegerTemplate(t_i13soi,vl_goodValues,vl_badValues);
}

//const test:
testcase tc_complementInt13roi_c_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i13roi_c,t_i13_eq);
}
testcase tc_complementInt13roi_c() runs on A
{
  var RoI vl_goodValues := {-1,19,23,24,100};  
  var RoI vl_badValues := { 20,21,22};
  f_checkIntegerTemplate(t_i13roi_c,vl_goodValues,vl_badValues);
}
testcase tc_complementInt13soi_c_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i13soi_c,t_i13_eq);
}
testcase tc_complementInt13soi_c() runs on A
{
  var RoI vl_goodValues := {-1,19,23,24,100};  
  var RoI vl_badValues := { 20,21,22};
  f_checkIntegerTemplate(t_i13soi_c,vl_goodValues,vl_badValues);
}
//====== templates derived from set of integers

//=== i0s ===
//complement(1, 2, (6..9));
testcase tc_complementInt0s_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i0s,t_i0s_eq);
}

testcase tc_complementInt0s() runs on A
{
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := {1,2,6,7,8,9};
  f_checkIntegerTemplate(t_i0s,vl_goodValues,vl_badValues);
}
//=== i1s ===
testcase tc_complementInt1s_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i1s,t_i1s_eq);
}

testcase tc_complementInt1s() runs on A
{
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000}; 
  var RoI vl_badValues := { 1,2,6,7,8,9,100}; 
  f_checkIntegerTemplate(t_i1s,vl_goodValues,vl_badValues);
}
//=== i2s ===
testcase tc_complementInt2s_eq() runs on A{
  f_checkIntTemplateEquivalence(t_i2s,t_i2s_eq);
}
testcase tc_complementInt2s() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100};  
  f_checkIntegerTemplate(t_i2s,vl_goodValues,vl_badValues);
}
//=== i3s ===
testcase tc_complementInt3s() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
  f_checkIntegerTemplate(t_i3s,vl_goodValues,vl_badValues);
}
//=== i4s ===
//order
testcase tc_complementInt4s() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
  f_checkIntegerTemplate(t_i4s,vl_goodValues,vl_badValues);
}

//=== i5s ===
//repetition
testcase tc_complementInt5s() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
  f_checkIntegerTemplate(t_i5s,vl_goodValues,vl_badValues);
}
//=== i6s ===
testcase tc_complementInt6s() runs on A
{
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
  f_checkIntegerTemplate(t_i6s,vl_goodValues,vl_badValues);
}


//-------- Tests for dynamic templates ( template variables) ----

//=== i0 ===
//complement(1, 2, (6..9));
testcase tc_complementInt0_eq_dyn() runs on A{
  var template integer tl_i0    := complement (all from t_RoI1);
  f_checkIntTemplateEquivalence(tl_i0,t_i0_eq);
}

testcase tc_complementInt0_eq_2dyn() runs on A{
  var template RoI tl_RoI1 :=  {1, 2, (6..9)};
  var template integer tl_i0    := complement (all from tl_RoI1);
  f_checkIntTemplateEquivalence(tl_i0,t_i0_eq);
}

testcase tc_complementInt0_dyn() runs on A
{
  var template integer tl_i0    := complement (all from t_RoI1);
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := {1,2,6,7,8,9};
  f_checkIntegerTemplate(tl_i0,vl_goodValues,vl_badValues);
}

testcase tc_complementInt0_2dyn() runs on A
{
  var template RoI tl_RoI1 :=  {1, 2, (6..9)};
  var template integer tl_i0    := complement(all from tl_RoI1);
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := {1,2,6,7,8,9};
  f_checkIntegerTemplate(tl_i0,vl_goodValues,vl_badValues);
}

//=== i1 ===
testcase tc_complementInt1_dyn() runs on A
{
  var template integer tl_i1 := complement (all from t_RoI1, 100);
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
  var RoI vl_badValues  := { 1,2,6,7,8,9,100}; 
  f_checkIntegerTemplate(tl_i1,vl_goodValues,vl_badValues);
}
testcase tc_complementInt1_2dyn() runs on A
{
  var template RoI tl_RoI1:= {1, 2, (6..9)};
  var template integer tl_i1 := complement(all from tl_RoI1, 100);
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
  var RoI vl_badValues :=  {1,2,6,7,8,9,100};
  f_checkIntegerTemplate(tl_i1,vl_goodValues,vl_badValues);
} 

//=== i2 ===
testcase tc_complementInt2_dyn() runs on A
{
  var template integer tl_i2 := complement(-1,0,all from t_RoI1, 100);
  var RoI vl_goodValues :=  { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100};  
  f_checkIntegerTemplate(tl_i2,vl_goodValues,vl_badValues);
}

testcase tc_complementInt2_2dyn() runs on A
{
  var template RoI tl_RoI1:= {1, 2, (6..9)};
  var template integer tl_i2 := complement(-1,0,all from tl_RoI1, 100);
  var RoI vl_goodValues := {-99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
  var RoI vl_badValues :=  {-1,0,1,2,6,7,8,9,100};  
  f_checkIntegerTemplate(tl_i2,vl_goodValues,vl_badValues);
}

//=== i3 ===
testcase tc_complementInt3_dyn() runs on A
{
  var template integer tl_i4 := complement(-1,0,all from t_RoI1, 100, all from t_RoI3);
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22}; 
  f_checkIntegerTemplate(tl_i4,vl_goodValues,vl_badValues);
}
 
testcase tc_complementInt3_2dyn() runs on A
{
  var template RoI tl_RoI1:= {1, 2, (6..9)};
  var template RoI tl_RoI3 := {20,21,22};
  var template integer tl_i4 := complement(-1,0,all from tl_RoI1, 100, all from tl_RoI3);
  var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000}; 
  var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22}; 
  f_checkIntegerTemplate(tl_i4,vl_goodValues,vl_badValues);
}

//=== i4 ===

//======== Dyn. Set Of Int=========================

//=== i0 ===
//complement(1, 2, (6..9));
testcase tc_complementInt0s_eq_dyn() runs on A{
  var template integer tl_i0s    := complement (all from t_SoI1);
  f_checkIntTemplateEquivalence(tl_i0s,t_i0s_eq);
}  

testcase tc_complementInt0s_eq_2dyn() runs on A{
  var template SoI tl_SoI1 :=  {1, 2, (6..9)};
  var template integer tl_i0s    := complement (all from tl_SoI1);
  f_checkIntTemplateEquivalence(tl_i0s,t_i0s_eq);
} 

testcase tc_complementInt0s_dyn() runs on A
{
  var template integer tl_i0s    := complement (all from t_SoI1);
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := {1,2,6,7,8,9};
  f_checkIntegerTemplate(tl_i0s,vl_goodValues,vl_badValues);
}

testcase tc_complementInt0s_2dyn() runs on A
{
  var template SoI tl_SoI1 :=  {1, 2, (6..9)};
  var template integer tl_i0s    := complement(all from tl_SoI1);
  var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};  
  var RoI vl_badValues := {1,2,6,7,8,9};
  f_checkIntegerTemplate(t_i0s,vl_goodValues,vl_badValues);
}

//=== i1s ===

//+++++++++ NEGATIVE TEST+++++++++++++++++++++++++
// see: TTCN3_SA_13_TD.script

//=========================================================
//===== Test for Record of charstring =====================
//=========================================================

testcase tc_complementCharstring1() runs on A
{
  var RoCS vl_goodValues := { "house","apples" };
  var RoCS vl_badValues := { "apple","banana","","pear", "dog" };  
  f_checkCharstringTemplate(t_cs1,vl_goodValues,vl_badValues);
}

testcase tc_complementCharstring2() runs on A
{
  var RoCS vl_goodValues := { "house","applesss","tree","a","app","appl","pple" };  
  var RoCS vl_badValues := { "apple","banana","","pear", "dog", "treeeeeeeeeeeeee","apples","bananas","pears" };
  f_checkCharstringTemplate(t_cs2,vl_goodValues,vl_badValues);
}

//=========================================================
//================== Test for Records =====================
//=========================================================
//====== Embedded templates ====
template MyRecord t_myrec1 := { i:= t_i1, roi:=t_RoI1, soi:=t_SoI1 }
template MyRecord t_myrec1_eq := { i:= t_i1_eq, roi:=t_RoI1, soi:=t_SoI1 }

template MyRecord t_myrec2 := { i:= t_i2, roi:=t_RoI1, soi:=t_SoI1 }
template MyRecord t_myrec2_eq := { i:= t_i2_eq, roi:=t_RoI1, soi:=t_SoI1 } 
  
testcase tc_complementMyRec1_eq() runs on A {
  f_checkMyRecordTemplateEquivalence(t_myrec1,t_myrec1_eq);
}

testcase tc_complementMyRec1() runs on A
{
  var RoMyRec vl_goodValues := { 
    {i:=3,roi:={1,2,6},soi:={1,7,2} },
    {i:=0,roi:={1,2,7},soi:={1,9,2} } };
  var RoMyRec vl_badValues := {{omit,omit,omit}  };  
  f_checkMyRecTemplate(t_myrec1,vl_goodValues,vl_badValues);
}

testcase tc_complementMyRec2_eq() runs on A {
  f_checkMyRecordTemplateEquivalence(t_myrec2,t_myrec2_eq);
}

//==== function reference =====
testcase tc_functionRef_rof_c_eq() runs on A {
  f_checkMyFunctionRefTemplateEquivalence( t_fref_int2int_c,t_fref_int2int_c_eq);
}


// control part is NOT used during the test!
control {
  //  execute(tc_complementInt_eq());
  execute(tc_complementInt0());
  execute(tc_complementInt1());
  execute(tc_complementInt2());
  execute(tc_complementInt3());
  execute(tc_complementInt4());
  execute(tc_complementInt5());
  execute(tc_complementInt6());  

  execute(tc_complementInt1s());
  execute(tc_complementInt2s());
  execute(tc_complementInt3s());
  execute(tc_complementInt4s());
  execute(tc_complementInt5s());
  execute(tc_complementInt6s());

  execute(tc_complementCharstring1());
  execute(tc_complementCharstring2());
}

}